#!/usr/bin/env python
# encoding: utf-8
#
# Copyright SAS Institute
#
#  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.
#

''' ESP Project '''

from __future__ import print_function, division, absolute_import, unicode_literals

import collections
import os
import re
import requests
import six
import threading
import xml.etree.ElementTree as ET
from six.moves import urllib
from .base import ESPObject, attribute
from .config import get_option
from .contquery import ContinuousQuery
from .exceptions import ESPError
from .mas import MASModule
from .windows import get_window_class
from .utils.rest import get_params
from .utils.data import get_project_data, gen_name
from .utils.events import get_events
from .utils.notebook import scale_svg
from .utils.project import expand_path
from .utils import xml


class ContinuousQueryDict(collections.MutableMapping):
    '''
    Dictionary for holding continuous query objects

    Attributes
    ----------
    project : string
        The name of the project
    session : requests.Session
        The session for the continuous queries

    Parameters
    ----------
    *args : one-or-more arguments, optional
        Positional arguments to MutableMapping
    **kwargs : keyword arguments, optional
        Keyword arguments to MutableMapping

    '''

    def __init__(self, *args, **kwargs):
        collections.MutableMapping.__init__(self, *args, **kwargs)
        self._data = dict()
        self.project = None
        self.session = None

    @property
    def project(self):
        '''
        The project that queries are associated with

        Returns
        -------
        string

        '''
        return self._project

    @project.setter
    def project(self, value):
        self._project = getattr(value, 'name', value)
        for item in self._data.values():
            item.project = self._project

    @property
    def session(self):
        '''
        The session for the queries

        Returns
        -------
        string

        '''
        return self._session

    @session.setter
    def session(self, value):
        self._session = value
        for item in self._data.values():
            item.session = self._session

    def __getitem__(self, key):
        return self._data[key]

    def __setitem__(self, key, value):
        if not isinstance(value, ContinuousQuery):
            raise TypeError('Only ContinuousQuery objects can be '
                            'values in a Project')
        value.name = key
        value.project = self.project
        value.session = self.session
        self._data[key] = value

    def __delitem__(self, key):
        del self._data[key]

    def __iter__(self):
        return iter(self._data)

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

    def __str__(self):
        return str(self._data)

    def __repr__(self):
        return repr(self._data)


class ConnectorGroup(object):
    '''
    Project connector group

    Attributes
    ----------
    entries : dict
        Collection of connectors

    Parameters
    ----------
    name : string
        The name of the group
    description : string, optional
        A description of the group

    Returns
    -------
    :class:`ConnectorGroup`

    '''

    def __init__(self, name, description=None):
        self.name = name
        self.description = description
        self.entries = {}

    def add_entry(self, connector, state):
        self.entries[connector] = state

    @classmethod
    def from_element(cls, data, session=None):
        if isinstance(data, six.string_types):
            data = xml.from_xml(data)

        out = cls(data.attrib['name'])

        for item in data.findall('./description'):
            out.description = item.text

        for item in data.findall('./connector-entry'):
            out.entries[item.attrib['connector']] = item.attrib['state']

        return out

    from_xml = from_element

    def to_element(self):
        out = xml.new_elem('connector-group', attrib=dict(name=self.name))

        if self.description:
            xml.add_elem(out, 'description', text_content=self.description)

        for key, value in six.iteritems(self.entries):
            xml.add_elem(out, 'connector-entry',
                         attrib=dict(connector=key, state=value))

        return out

    def to_xml(self, pretty=False):
        return xml.to_xml(self.to_element(), pretty=pretty)


class Edge(object):

    def __init__(self, source, target):
        self.source = source
        if isinstance(target, six.string_types):
            self.target = re.split(r'\s*,\s*', target)
        else:
            self.target = list(target)

    @classmethod
    def from_element(cls, data, session=None):
        return cls(data.attrib['source'], data.attrib['target'])

    def to_element(self):
        return xml.new_elem('edge',
                            attrib=dict(source=self.source,
                                        target=','.join(self.target)))


class Project(ESPObject, collections.MutableMapping):
    '''
    ESP Project

    Parameters
    ----------
    name : string
        Name of the project
    n_threads : int, optional
        A positive integer for the number of threads to use from the
        available thread pool
    pubsub : string, optional
        Publish/subscribe mode for the project
    compress_open_patterns : bool, optional
        When True, compress events stored in unresolved pattern instances
    port : int, optional
        The project-level publish/subscribe port for auto or manual mode
    index_type : string, optional
        A default index type for all windows in the project that do not
        explicitly specify an index type
        Valid values: 'rbtree', 'hash', 'ln_hash', 'cl_hash', 'fw_hash', 'empty'
    use_tagged_token : bool, optional
        Specify whether tagged token data flow semantics should be used
        for continuous queries
    use_retention_tracking : bool, optional
        Specify whether to use retention tracking for the project.
        This allows two events per key in output event blocks.
    disk_store_path : string, optional
        Specify the path for on-disk event storage when using hleveldb indices
    heartbeat_interval : int, optional
        Specify how frequently the system sends timer heartbeats to the project.
        The default value is 1 second. This heartbeat drives wall-clock-based
        retention and pattern time outs. When a model has an exceptionally large
        number of unresolved pattern instances, increasing the value of the
        heartbeat interval can optimize how the model runs.
    restore : string, optional
        Specify a directory from which to restore the project from a
        previously-performed persist operation.
    description : string, optional
        Description of the project
    metadata : dict, optional
        Metadata associated with the project

    Attributes
    ----------
    queries : dict
        Dictionary of the queries
    metadata : dict
        Metadata associated with the project
    url : string
        The URL of the project

    Notes
    -----
    All parameters to the constructor are also available as attributes.

    Returns
    -------
    :class:`Project`

    '''

    default_query = 'contquery'

    n_threads = attribute('threads', dtype='int')
    pubsub = attribute('pubsub', dtype='string', values=['none', 'auto', 'manual'])
    port = attribute('port', dtype='int')
    index_type = attribute('index', dtype='string',
                           values={'rbtree': 'pi_RBTREE', 'hash': 'pi_HASH',
                                   'ln_hash': 'pi_LN_HASH', 'cl_hash': 'pi_CL_HASH',
                                   'fw_hash': 'pi_FW_HASH', 'empty': 'pi_EMPTY'})
    name = attribute('name', dtype='string')
    use_tagged_token = attribute('use-tagged-token', dtype='bool')
    use_retention_tracking = attribute('retention-tracking', dtype='bool')
    restore = attribute('restore', dtype='string')
    disk_store_path = attribute('disk-store-path', dtype='string')
    heartbeat_interval = attribute('heartbeat-interval', dtype='int')
    compress_open_patterns = attribute('compress-open-patterns', dtype='bool')

    def __init__(self, name=None, n_threads=1, pubsub='auto',
                 compress_open_patterns=None, port=None, index_type=None,
                 use_tagged_token=None, use_retention_tracking=None,
                 disk_store_path=None, heartbeat_interval=None, restore=None,
                 description=None, sas_log_location=None, sas_connection_key=None,
                 sas_command=None, metadata=None):
        self.queries = ContinuousQueryDict()
        ESPObject.__init__(self, attrs=locals())
        self.name = name or gen_name(prefix='p_')
        self.description = description
        self.sas_log_location = sas_log_location
        self.sas_connection_key = sas_connection_key
        self.sas_command = sas_command
        self.mas_modules = []
        self.connector_groups = {}
        self.edges = []
        self.metadata = dict(metadata or {})

    @property
    def session(self):
        '''
        The requests.Session object for the project

        Returns
        -------
        string

        '''
        return ESPObject.session.fget(self)

    @session.setter
    def session(self, value):
        ESPObject.session.fset(self, value)
        self.queries.session = value

    @property
    def name(self):
        '''
        The name of the project

        Returns
        -------
        string

        '''
        return self._name

    @name.setter
    def name(self, value):
        '''
        Set the name of the project and propagate to sub-objects

        Parameters
        ----------
        value : string
            The name of the project

        '''
        self._name = value
        self.queries.project = self.name

    @property
    def windows(self):
        '''
        Return collection of windows from the default query

        Returns
        -------
        dict

        '''
        if self.default_query not in self.queries:
            self.queries[self.default_query] = ContinuousQuery()
        return self.queries[self.default_query].windows

    @property
    def trace(self):
        '''
        Set the trace property on the default continuous query

        Returns
        -------
        string

        '''
        if self.default_query not in self.queries:
            self.queries[self.default_query] = ContinuousQuery()
        return self.queries[self.default_query].trace

    @trace.setter
    def trace(self, value):
        '''
        Set the trace property on the default continuous query

        Parameters
        ----------
        value : string
            The names of the windows to trace

        '''
        if self.default_query not in self.queries:
            self.queries[self.default_query] = ContinuousQuery()
        self.queries[self.default_query].trace = value

    def sync(self, overwrite=True, start=True, start_connectors=True):
        '''
        Sync the project definition to the server

        Notes
        -----
        This will overwrite the project definition in the server.

        Parameters
        ----------
        overwrite : bool, optional
            Should an existing project with the same name be overwritten?
        start : bool, optional
            Should the project be started?
        start_connectors : bool, optional
            Should the connectors be started?

        '''
        self._put(params=get_params(overwrite=overwrite,
                                    connectors=start_connectors,
                                    start=start),
                  data=get_project_data(self))

    def copy(self, deep=False):
        '''
        Return a copy of the object

        Parameters
        ----------
        deep : bool, optional
            Should sub-objects be copied as well?

        Returns
        -------
        :class:`Project`

        '''
        out = type(self)()

        out.session = self.session

        for key, value in self._get_attributes(use_xml_values=False).items():
            setattr(out, key, value)

        if deep:
            out.queries = dict([(k, v.copy(deep=True))
                                for k, v in self.queries.items()])
        else:
            out.queries.update(self.queries)

        return out

    def __copy__(self):
        return self.copy(deep=False)

    def __deepcopy__(self, memo):
        return self.copy(deep=True)

    @property
    def fullname(self):
        return self.name

    @property
    def url(self):
        '''
        URL of project

        Returns
        -------
        string

        '''
        return urllib.parse.urljoin(self.base_url, 'projects/%s/' % self.name)

    @classmethod
    def from_element(cls, data, session=None):
        '''
        Create project from XML definition

        Parameters
        ----------
        data : xml-string or ElementTree.Element
            XML project definition
        session : requests.Session, optional
            Session that the project is associated with

        Returns
        -------
        :class:`Project`

        '''
        out = cls()
        out.session = session

        if isinstance(data, six.string_types):
            data = xml.from_xml(get_project_data(data))

        if data.tag != 'project':
            data = data.find('.//project')

        if data is None:
            raise ValueError('No project found in input.')

        out._set_attributes(data.attrib)

        for desc in data.findall('./description'):
            out.description = desc.text

        for item in data.findall('./ds-initialize'):
            out.sas_log_location = item.attrib.get('sas-log-location')
            out.sas_connection_key = item.attrib.get('sas-connection-key')
            out.sas_command = item.attrib.get('sas-command')

        for item in data.findall('./mas-modules/mas-module'):
            out.mas_modules.append(MASModule.from_xml(item, session=session))

        for item in data.findall('./project-connectors/connector-groups/connector-group'):
            grp = ConnectorGroup.from_element(item, session=session)
            out.connector_groups[grp.name] = grp

        for item in data.findall('./project-connectors/edges/edge'):
            out.edges.append(Edge.from_element(item, session=session))

        for contquery in data.findall('.//contquery'):
            query = ContinuousQuery.from_xml(contquery, project=out,
                                             session=session)
            out.queries[query.name] = query

        for item in data.findall('./metadata/meta'):
            out.metadata[item.attrib['id']] = item.text

        return out

    from_xml = from_element

    def _load_metadata(self):
        data = self._get(urllib.parse.urljoin(self.base_url,
                                              'projectMetadata/%s' % self.name))
        for item in data.findall('./project/metadata/meta'):
            self.metadata[item.attrib['id']] = item.text
        for cq in data.findall('./project/contquery'):
            name = cq.attrib['id']
            if name in self.queries:
                for item in cq.findall('./metadata/meta'):
                    self.queries[name].metadata[item.attrib['id']] = item.text

    def _persist_metadata(self):
        if self.metadata:
            self._set_metadata(self.metadata)
        for cq in six.itervalues(self.queries):
            if cq.metadata:
                cq._set_metadata(cq.metadata)

    def _clear_metadata(self):
        self.metadata.clear()
        for cq in six.itervalues(self.queries):
            cq._clear_metadata()

    def _get_metadata(self):
        out = {}
        for item in self._get(urllib.parse.urljoin(self.base_url,
                                                   'projectMetadata/%s' % self.name)
                             ).findall('./project/metadata/meta'):
            out[item.attrib['id']] = item.text
        return out

    def _set_metadata(self, data):
        for key, value in six.iteritems(data):
            self._put(urllib.parse.urljoin(self.base_url,
                                           'projectMetadata/%s/%s' % (self.name, key)),
                      data='%s' % value)

    def _del_metadata(self, *data):
        for key in data:
            self._delete(urllib.parse.urljoin(self.base_url,
                                              'projectMetadata/%s/%s' % (self.name, key)))

    def to_element(self):
        '''
        Export project definition to an ElementTree.Element

        Returns
        -------
        :class:`ElementTree.Element`

        '''
        out = xml.new_elem('engine')
        projects = xml.add_elem(out, 'projects')

        proj = xml.add_elem(projects, 'project', xml.get_attrs(self, extra='name'))

        if self.description:
            xml.add_elem(proj, 'description', text_content=self.description)

        if self.metadata:
            metadata = xml.add_elem(proj, 'metadata')
            for key, value in sorted(six.iteritems(self.metadata)):
                xml.add_elem(metadata, 'meta', attrib=dict(id=key),
                             text_content=value)

        if self.sas_log_location or self.sas_connection_key or self.sas_command:
            xml.add_elem(proj, 'ds-initialize',
                         attrib=dict(sas_log_location=self.sas_log_location,
                                     sas_connection_key=self.sas_connection_key,
                                     sas_command=self.sas_command))

        if self.mas_modules:
            mods = xml.add_elem(proj, 'mas-modules')
            for item in self.mas_modules:
                xml.add_elem(mods, item.to_element())

        queries = xml.add_elem(proj, 'contqueries')

        for name, query in sorted(six.iteritems(self.queries)):
            xml.add_elem(queries, query.to_element())

        if self.connector_groups or self.edges:
            conns = xml.add_elem(proj, 'project-connectors')

            if self.connector_groups:
                grps = xml.add_elem(conns, 'connector-groups')
                for name, value in sorted(six.iteritems(self.connector_groups)):
                    xml.add_elem(grps, value.to_element())

            if self.edges:
                edges = xml.add_elem(conns, 'edges')
                for item in self.edges:
                    xml.add_elem(edges, item.to_element())

        return out

    def to_xml(self, pretty=False):
        '''
        Export project definition to XML

        Parameters
        ----------
        pretty : bool, optional
            Should the XML include whitespace for readability?

        Returns
        -------
        string

        '''
        return xml.to_xml(self.to_element(), pretty=pretty)

    def save_xml(self, dest, mode='w', pretty=True, **kwargs):
        '''
        Save the project XML to a file

        Parameters
        ----------
        dest : string or file-like
            The destination of the XML content
        mode : string, optional
            The write mode for the output file (only used if `dest` is a string)
        pretty : boolean, optional
            Should the XML include whitespace for readability?

        '''
        if isinstance(dest, six.string_types):
            with open(dest, mode=mode, **kwargs) as output:
                output.write(self.to_xml(pretty=pretty))
        else:
            dest.write(self.to_xml(pretty=pretty))

    def to_graph(self, graph=None, schema=False):
        '''
        Export project definition to graphviz.Digraph

        Parameters
        ----------
        graph : graphviz.Digraph, optional
            The parent graph to add to
        schema : bool, optional
            Should window schemas be included?

        Returns
        -------
        :class:`graphviz.Digraph`

        '''
        try:
            import graphviz as gv
        except ImportError:
            raise ImportError('The graphviz module is required for exporting to graphs.')

        if graph is None:
            graph = gv.Digraph(format='svg')
            graph.attr('node', shape='rect', fontname='helvetica')
            graph.attr('graph', rankdir='LR', center='false')
            graph.attr('edge', fontname='times-italic')

        if self.queries:
            pgraph = gv.Digraph(format='svg',
                                name='cluster_%s' % self.fullname.replace('.', '_'))
            pgraph.attr('graph', fontname='helvetica')
            pgraph.attr('edge', fontname='times-italic')
            pgraph.attr(label=self.name, labeljust='l',
                        style='filled,bold,rounded', color='#c0c0c0',
                        fillcolor='#dadada', fontcolor='black')

            if list(self.queries.keys()) == [self.default_query]:
                for wkey, win in sorted(self.windows.items()):
                    pgraph.subgraph(win.to_graph(schema=schema))
                    for target in win.targets:
                        graph.edge(win.fullname, self.windows[target.name].fullname,
                                   label=target.role or '')
            else:
                for qkey, query in sorted(self.queries.items()):
                    pgraph.subgraph(query.to_graph(schema=schema))

            graph.subgraph(pgraph)

        else:
            graph.node(self.fullname, label=self.name, labeljust='l',
                       style='filled,bold,rounded', color='#c0c0c0',
                       fillcolor='#dadada', fontcolor='black')

        return graph

    def _repr_svg_(self):
        try:
            return scale_svg(self.to_graph()._repr_svg_())
        except ImportError:
            raise AttributeError('_repr_svg_')

    def __str__(self):
        return '%s(name=%s)' % (type(self).__name__, repr(self.name))

    def __repr__(self):
        return str(self)

    def start(self):
        ''' Start the project '''
        self._put('state', params=dict(value='running'))

    def stop(self):
        ''' Stop the project '''
        self._put('state', params=dict(value='stopped'))

    def start_connectors(self):
        ''' Start the connectors for the project '''
        self._put('state', params=dict(value='connectorsStarted'))

    def add_connectors(self, group_name, connectors, group_description=None):
        '''
        Add connectors to a group

        Parameters
        ----------
        group_name : string
            The name of the connector group
        connectors : dict
            Key / value pairs of connector names and states
            ('finished', 'running', 'stopped')
        group_description : string, optional
            A description of the group

        Notes
        -----
        If the connector group does not exist yet, one is created.
        If the connector group does exist, the connectors will be
        added to it.

        '''
        if group_name not in self.connector_groups:
            self.connector_groups[group_name] = ConnectorGroup(group_name,
                                                    description=group_description)

        group = self.connector_groups[group_name]

        for key, value in six.iteritems(connectors):
            group.add_entry(key, value)

    def add_edge(self, source, targets):
        '''
        Add connector edges

        Parameters
        ----------
        source : string
           Name of the source
        targets : string or list-of-strings
           If a string, then it is a single target.  If a list, then
           it is a list of target names.

        '''
        if isinstance(targets, six.string_types):
            targets = [targets]
        self.edges.append(Edge(source, targets)) 

    def save(self, path=None):
        '''
        Save the project

        Parameters
        ----------
        path : string
            Directory to save the project in

        '''
        self._put('state', params=get_params(value='persisted', path=path))

    def restore(self, path=None):
        '''
        Restore the project

        Parameters
        ----------
        path : string
            Directory where project was saved

        '''
        self._put('state', params=get_params(value='restored', path=path))

    def update(self, project):
        '''
        Update project definition

        Parameters
        ----------
        project : string
            Location of the project data

        '''
        self._put('state', params=get_params(value='modified'),
                  data=get_project_data(project))

    def delete(self):
        ''' Delete the project '''
        self._delete()

    def create_mas_module(self, language, module, func_names, mas_store=None,
                          mas_store_version=None, description=None,
                          code_file=None, code=None):
        '''
        Create a MAS module object

        Parameters
        ----------
        language : string
            The name of the programming language
        module : string, optional
            Name of the MAS module
        func_names : string or list-of-strings, optional
            The function names exported by the module

        Returns
        -------
        :class:`MASModule`

        '''
        out = MASModule(language, module, func_names, mas_store=mas_store,
                        mas_store_version=mas_store_version,
                        description=description, code_file=code_file,
                        code=code)
        out.project = self.name
        out.session = self.session
        return out

    def get_mas_modules(self, expandcode=False):
        '''
        Retrieve all MAS modules

        Parameters
        ----------
        expandcode : bool, optional
            If True, return code-file elements as code elements containing
            the contents of the file.

        Returns
        -------
        list of :class:`MASModule`s

        '''
        res = self._get(urllib.parse.urljoin(self.base_url,
                                             'masModules/%s' % self.name),
                        params=get_params(expandcode=expandcode))
        modules = []
        for elem in res.findall('./project'):
            for mod in elem.findall('./mas-module'):
                mod = MASModule.from_xml(mod, session=self.session)
                mod.project = self.name
                modules.append(mod)
        return modules

    def get_mas_module(self, name, expandcode=False):
        '''
        Retrieve specified MAS modules

        Parameters
        ----------
        name : string
            Name of the MAS module
        expandcode : bool, optional
            If True, return code-file elements as code elements containing
            the contents of the file.

        Returns
        -------
        :class:`MASModule`

        '''
        res = self._get(urllib.parse.urljoin(self.base_url,
                                             'masModules/%s/%s' %
                                             (self.name, name)),
                        params=get_params(expandcode=expandcode))
        mod = MASModule.from_xml(res, session=self.session)
        mod.project = self.name
        return mod

    def replace_mas_module(self, name, module):
        '''
        Replace the specified MAS module

        Parameters
        ----------
        name : string
            Name of the MAS module
        module : string or MASModule
            MAS module configuration

        '''
        self._put(urllib.parse.urljoin(self.base_url,
                                       'masModules/%s/%s' % (self.name, name)),
                  data=get_project_data(module))

    def get_stats(self, interval=None, min_cpu=None, limit=20):
        '''
        Retrieve project statistics subscriber

        Parameters
        ----------
        interval : int, optional
            The interval in seconds between updates
        min_cpu : int, optional
            The minimum CPU value you want included
        limit : int, optional
            The maximum number of rows to retain in the DataFrame

        Returns
        -------
        :class:`ProjectStats`

        '''
        from .connection import ProjectStats
        proj_stats = ProjectStats(self, interval=interval, min_cpu=min_cpu,
                                  limit=limit)
        proj_stats.start()
        return proj_stats

    def validate(self):
        '''
        Validate the project definition

        Returns
        -------
        True
            If project is valid
        False
            If project is not valid

        '''
        try:
            res = self._post(urllib.parse.urljoin(self.base_url,
                                                  'projectValidationResults'),
                             data=self.to_xml())
            if res.tag != 'schema-validation-success':
                return False
        except ESPError:
            return False
        return True

    def add_window(self, window, contquery=None):
        '''
        Add a window to the project

        Parameters
        ----------
        window : Window
            The Window object to add
        contquery : string or ContinuousQuery, optional
            The name of the continuous query the window belongs to.
            If not specified, the default continuous query will
            be used.

        Returns
        -------
        :class:`Window`

        '''
        if contquery is None:
            contquery = self.default_query
        else:
            contquery = getattr(contquery, 'name', contquery)

        if contquery not in self.queries:
            self.queries[contquery] = ContinuousQuery()

        self.queries[contquery].add_window(window)

        return window

    def add_query(self, contquery):
        '''
        Add a continuous query object

        Parameters
        ----------
        contquery : string or ContinuousQuery
            The name of the continuous query to create, or a
            ContinuousQuery object to add to the project

        Returns
        -------
        :class:`ContinuousQuery`

        '''
        if isinstance(contquery, six.string_types):
            self.queries[contquery] = ContinuousQuery()
            return self.queries[contquery]
        else:
            if not contquery.name:
                contquery.name = gen_name(prefix='cq_')
            self.queries[contquery.name] = contquery
            return self.queries[contquery.name]

    add_continuous_query = add_query

    add_contquery = add_query

    def get_windows(self, path='*.*', type=None, filter=None):
        '''
        Retrieve windows from the server

        Parameters
        ----------
        path : string, optional
            '.' delimited path to windows to retrieve.  '*' can be used as
            a wildcard for any component.  Multiple component names can
            be delimited by '|'.
        type : string or list-of-strings, optional
            Types of windows you want to retrieve
        filter : string or list-of-strings, optional
            Function filter indicating which windows to retrieve

        Notes
        -----
        This method retrieves window definitions from the server, not
        from the collection of windows held locally in this projects
        variables.

        Returns
        -------
        list of :class:`Window`

        '''
        path = [None, None] + expand_path(path)
        res = self._get(urllib.parse.urljoin(self.base_url, 'windowXml'),
                        params=get_params(project=self.name,
                                          contquery=path[-2],
                                          name=path[-1], type=type,
                                          filter=filter))
        windows = {}
        for item in res.findall('./*'):
            try:
                wcls = get_window_class(item.tag)
            except KeyError:
                raise TypeError('Unknown window type: %s' % item.tag)
            window = wcls.from_xml(item, session=self.session)
            windows[window.name] = window
        return windows

    def get_window(self, path):
        '''
        Retrieve specified window

        Parameters
        ----------
        path : string
            '.' delimited path to the window including continuous query
            name and window name.

        Notes
        -----
        This method retrieves window definitions from the server, not
        from the collection of windows held locally in this projects
        variables.

        Returns
        -------
        :class:`Window`

        '''
        out = self.get_windows(path)
        if out and len(out) == 1:
            return out[list(out.keys())[0]]
        raise KeyError("No window with the path '%s'." % path)

#
# MutableMapping methods
#

    def __getitem__(self, key):
        return self.queries[key]

    def __setitem__(self, key, value):
        value.project = self.name
        self.queries[key] = value

    def __delitem__(self, key):
        del self.queries[key]

    def __iter__(self):
        return iter(self.queries)

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

    def __contains__(self, value):
        return value in self.queries
