pyqttoolkit 0.9.1__py3-none-any.whl

pyqttoolkit/properties/auto.py

@@ -0,0 +1,221 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# 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 this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+""":mod:`toolkit`
+Defines various utils useful in views
+"""
+import logging
+from math import isnan
+from weakref import ref, WeakKeyDictionary
+
+from pyqttoolkit.logs import TRACE
+
+LOGGER = logging.getLogger(__name__)
+
+def updater(obj, name):
+    """function::updater(obj, name)
+    Higher order function which returns a function to update the property
+    specified by name in the object specified by obj
+    """
+    def _update_value(value):
+        setattr(obj, name, value)
+    return _update_value
+
+def one_way_bind(src, dest, src_name, dest_name=None):
+    """function::one_way_bind(src, dest, src_name, [dest_name])
+    Propagate changes in src to dest, and set dest to value of src
+    """
+    dest_name = dest_name or src_name
+    src_signal = getattr(type(src), AutoProperty.get_notify_property_name(src_name))
+    dest_prop = getattr(type(dest), dest_name)
+    src_signal.__get__(src, type(src)).connect(dest_prop.updater(dest))
+    src_value = getattr(src, src_name)
+    setattr(dest, dest_name, src_value)
+    return updater
+
+def bind(src, dest, src_name, dest_name=None, two_way=True):
+    """function::bind(src, dest, src_name, [dest_name[, two_way]])
+    Propagate changes in src to dest, and set dest to value of src
+    Optionally bind dest to src
+    """
+    dest_name = dest_name or src_name
+    one_way_bind(src, dest, src_name, dest_name)
+    if two_way:
+        one_way_bind(dest, src, dest_name, src_name)
+
+def one_way_unbind(src, dest, src_name, dest_name=None):
+    dest_name = dest_name or src_name
+    src_signal = getattr(type(src), AutoProperty.get_notify_property_name(src_name))
+    dest_prop = getattr(type(dest), dest_name)
+    src_signal.__get__(src, type(src)).disconnect(dest_prop.updater(dest))
+
+def unbind(src, dest, src_name, dest_name=None, two_way=True):
+    dest_name = dest_name or src_name
+    one_way_unbind(src, dest, src_name, dest_name)
+    if two_way:
+        one_way_unbind(dest, src, dest_name, src_name)
+
+def auto_property(type_, *args, **kwargs):
+    """function::auto_property(type, *args, **kwargs)
+    Decorator function for AutoProperty, creates an AutoProperty with the given getter
+    """
+    def _(fget):
+        return AutoProperty(type_=type_, fget=fget, *args, **kwargs)
+    return _
+
+def values_equal(left, right):
+    return left == right or (isinstance(left, float) and isinstance(right, float) and isnan(left) and isnan(right))
+
+def connect_all(handler, *signals):
+    for signal in signals:
+        signal.connect(handler)
+
+def disconnect_all(handler, *signals):
+    for signal in signals:
+        signal.disconnect(handler)
+
+#pylint: disable=too-many-arguments
+class AutoProperty:
+    """class::AutoProperty
+    Descriptor which provides property and signal functionality to objects
+    """
+    native_types = [list, str, int, float, bool]
+    def __init__(self, type_, fget=None, fset=None, fdel=None, default_value=None, notify=None):
+        self._type = type_
+        self._default_value = default_value
+        self._notify = notify
+        self._name = None
+        self._fget = fget
+        self._fset = fset
+        self._fdel = fdel
+        self._updaters = WeakKeyDictionary()
+        self._notify_depth = 0
+        self._max_notify_depth = 5
+
+    def __set_name__(self, obj, name):
+        self._name = name
+        if not self._notify and self._has_notify_property(obj):
+            self._notify = self._get_notify_property(obj)
+
+    def __get__(self, obj, type_=None):
+        if obj is None:
+            return self
+        if not self._name:
+            raise ValueError('Cannot get property, name has not been set!')
+        if self._uses_delegates():
+            if not self._fget:
+                raise ValueError(f'No getter provided for property {self._name}')
+            return self._fget(obj)
+        elif self._name not in obj.__dict__:
+            return self._default_value
+        else:
+            return obj.__dict__[self._name]
+
+    def __set__(self, obj, value):
+        if obj is None:
+            return
+        if not self._name:
+            raise ValueError('Cannot set property, name has not been set!')
+        if not self._uses_delegates() and not self._notify:
+            raise ValueError(f'Cannot set property {self._name}, unable to notify!')
+        if value is not None and self._type and not isinstance(value, self._type):
+            value_type = type(value)
+            raise ValueError(
+                f'Invalid type {value_type} provided for property {self._name}: '
+                f'must be of type {self._type}'
+            )
+        if self._uses_delegates():
+            if not self._fset:
+                raise ValueError(f'No setter provided for property {self._name}')
+            self._fset(obj, value)
+        elif self._name not in obj.__dict__ or not values_equal(obj.__dict__[self._name], value):
+            LOGGER.log(TRACE, 'Setting %s.%s to %s', obj, self._name, value)
+            obj.__dict__[self._name] = value
+            if self._notify_depth == self._max_notify_depth:
+                LOGGER.error('Maximum notify depth exceeded for %s.%s', obj, self._name)
+            if self._notify and self._notify_depth <= self._max_notify_depth:
+                self._notify_depth += 1
+                LOGGER.log(TRACE, 'Notifying change of %s.%s to %s', obj, self._name, value)
+                self._notify.__get__(obj, type(obj)).emit(value)
+                self._notify_depth -= 1
+
+    def __delete__(self, obj):
+        if not self._name:
+            raise ValueError('Cannot delete property, name has not been set!')
+        if self._uses_delegates():
+            if not self._fdel:
+                raise ValueError(f'No deleter provided for property {self._name}')
+            self._fdel(obj)
+        else:
+            del obj.__dict__[self._name]
+
+    def updater(self, obj, outer_value=None):
+        """function::updater(self, obj, outer_value=None)
+        Returns a function that can be used to update with the specified outer_value
+        If outer_value is not specified, updates with the inner_value passed to the inner function
+        """
+        if not obj in self._updaters:
+            obj_ref = ref(obj)
+            def _(inner_value=None):
+                self.__set__(obj_ref(), outer_value or inner_value)
+            self._updaters[obj] = _
+        return self._updaters[obj]
+
+    def getter(self, fget):
+        """function::getter(self, fget)
+        Function decorator to create a getter
+        Returns a copy of this AutoProperty with fget as the getter
+        """
+        return type(self)(
+            self._type, fget, self._fset, self._fdel,
+            self._default_value, self._notify
+        )
+
+    def setter(self, fset):
+        """function::setter(self, fset)
+        Function decorator to create a setter
+        Returns a copy of this AutoProperty with fset as the setter
+        """
+        return type(self)(
+            self._type, self._fget, fset, self._fdel,
+            self._default_value, self._notify
+        )
+
+    def deleter(self, fdel):
+        """function::deleter(self, fdel)
+        Function decorator to create a deleter
+        Returns a copy of this AutoProperty with fdel as the deleter
+        """
+        return type(self)(
+            self._type, self._fget, self._fset, fdel,
+            self._default_value, self._notify
+        )
+
+    def _get_notify_property(self, obj):
+        return getattr(obj, self.get_notify_property_name(self._name))
+
+    def _has_notify_property(self, obj):
+        return hasattr(obj, self.get_notify_property_name(self._name))
+
+    def _uses_delegates(self):
+        return self._fget or self._fset or self._fdel
+
+    @staticmethod
+    def get_notify_property_name(name):
+        """function::get_notify_property_name(name)
+        Returns the name of the notify property
+        """
+        return f'{name}Changed'

pyqttoolkit/properties/throttled.py

@@ -0,0 +1,77 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# 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 this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+import time
+from inspect import signature
+
+#pylint: disable=no-name-in-module
+from PyQt5.QtCore import QTimer
+#pylint: enable=no-name-in-module
+
+def arg_count(f):
+    return len(signature(f).parameters)
+
+class ThrottledBoundSignal:
+    def __init__(self, *types, interval=100):
+        self._types = types
+        self._interval = interval
+        self._functions = []
+        self._timer = None
+        self._last_event_time = 0
+        self._current_values = None
+    
+    def emit(self, *values):
+        self._current_values = values
+        time_since_last_event = time.clock() - self._last_event_time
+        if self._timer is None and time_since_last_event >= (self._interval / 1000):
+            self._emit_now()
+            return
+        if self._timer is None:
+            self._timer = QTimer()
+            self._timer.setSingleShot(True)
+            self._timer.timeout.connect(self._emit_now)
+            self._timer.start(self._interval)
+
+    def _emit_now(self):
+        for f in self._functions:
+            f(*self._current_values[:arg_count(f)])
+        self._last_event_time = time.clock()
+        self._current_values = None
+        self._timer = None
+    
+    def connect(self, f):
+        self._functions.append(f)
+
+    def disconnect(self, f):
+        self._functions.remove(f)
+
+class ThrottledSignal:
+    def __init__(self, *types, interval=1000):
+        self._name = None
+        self._types = types
+        self._interval = interval
+    
+    def __set_name__(self, obj, name):
+        self._name = name
+    
+    def __get__(self, obj, type_=None):
+        if obj is None:
+            return self
+        if not self._name:
+            raise ValueError('Cannot get property, name has not been set!')
+        if self._name not in obj.__dict__:
+            obj.__dict__[self._name] = ThrottledBoundSignal(*self._types, interval=self._interval)
+        return obj.__dict__[self._name]

pyqttoolkit/scripting/__init__.py

@@ -0,0 +1,19 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# 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 this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from .script_runner import ScriptRunner
+from .script_context import ScriptContext
+from .script_template import ScriptTemplate

pyqttoolkit/scripting/script_context.py

@@ -0,0 +1,36 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# 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 this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+class ScriptContext:
+    def __init__(self, **kwargs):
+        self._locals = kwargs
+        self._result = {'value': None}
+        self._output = ''
+    
+    @property
+    def locals(self):
+        return {**self._locals, 'result': self._result}
+    
+    @property
+    def result(self):
+        return self._result['value']
+    
+    @property
+    def output(self):
+        return self._output
+
+    def add_output(self, value):
+        self._output += value

pyqttoolkit/scripting/script_runner.py

@@ -0,0 +1,132 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# 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 this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from contextlib import contextmanager
+from functools import partial
+import re
+import builtins
+import sys
+import importlib
+
+@contextmanager
+def add_paths(paths):
+    for path in paths:
+        sys.path.insert(0, path)
+    try:
+        yield
+    finally:
+        for path in paths:
+            sys.path.remove(path)
+
+class ContextWriter:
+    def __init__(self, context, skip_empty_output_lines=False):
+        self._context = context
+        self._skip_empty_output_lines = skip_empty_output_lines
+    
+    def write(self, value):
+        if (value is not None and value.strip()) or not self._skip_empty_output_lines:
+            self._context.add_output(value)
+
+@contextmanager
+def redirect_output(context, skip_empty_output_lines=False):
+    writer = ContextWriter(context, skip_empty_output_lines)
+    _stdout = sys.stdout
+    sys.stdout = writer
+    try:
+        yield
+    finally:
+        sys.stdout = _stdout
+
+class ScriptStopped(Exception):
+    def __init__(self):
+        Exception.__init__(self)
+
+class ScriptRunner:    
+    def __init__(self, additional_paths=None, skip_empty_output_lines=False):
+        self._disallowed_modules = [
+            r'\binspect\b', r'\bimp\b', r'\bsys\b', r'\b\.', r'\bbuiltins\b'
+        ]
+        self._disallowed_globals = [
+            '_', 'quit', 'eval', 'exec', 'help'
+        ]
+        self._additional_paths = additional_paths or []
+        self._context = None
+        self._skip_empty_output_lines = skip_empty_output_lines
+
+    def run(self, script, context):
+        script = re.sub(r'(?<!\w)result(?!\w)', 'result[\'value\']', script)
+        code = self.compile(script)
+        try:
+            self._context = context
+            with redirect_output(self._context, self._skip_empty_output_lines):
+                # Use one namespace so functions defined by the script can
+                # resolve each other recursively through their globals. Add
+                # runner globals last so context locals cannot replace
+                # protected entries such as __builtins__.
+                namespace = {**context.locals, **self._globals(context)}
+                #pylint: disable=exec-used
+                exec(code, namespace, namespace)
+                #pylint: enable=exec-used
+        except ScriptStopped:
+            pass
+        finally:
+            self._context = None
+        
+    def _globals(self, context):
+        return {'__builtins__': {**__builtins__, '__import__': self._import(builtins.__import__), 'exit': self._exit, **{g: self._not_implemented for g in self._disallowed_globals}}}
+
+    def compile(self, script):
+        return compile(script, 'code', 'exec')
+
+    def _patch_plt_show(self, module):
+        def plt_show_as_show_figure(plt, block=None):
+            # Block is not used in the context of the script runner
+            for no, label in zip(plt.get_fignums(), plt.get_figlabels()):
+                self._context.show_figure(plt.figure(no), str(label))
+            plt.close('all')
+        if module.__name__ == 'matplotlib.pyplot':
+            module.show = partial(plt_show_as_show_figure, module)
+        if module.__name__ == 'matplotlib':
+            module.pyplot.show = partial(plt_show_as_show_figure, module.pyplot)
+        return module
+
+    def _import(self, import_function):
+        def _(module_name, *args, **kwargs):
+            if any(re.match(m, module_name) for m in self._disallowed_modules):
+                raise ImportError('Module not found')
+            try:
+                with add_paths(self._additional_paths):
+                    module = import_function(module_name, *args, **kwargs)
+                if module_name in 'importlib':
+                    module.import_module = self._import(importlib.import_module)
+                return self._patch_plt_show(module)
+            except KeyError:
+                raise ImportError('Module not found')
+        return _
+    
+    def _additional_paths(self):
+        return self._additional_paths
+    
+    def _exit(self):
+        raise ScriptStopped()
+    
+    def add_path(self, path):
+        if path in self._additional_paths:
+            self._additional_paths.remove(path)
+        self._additional_paths.insert(0, path)
+
+    def _not_implemented(self, *args, **kwargs):
+        raise NotImplementedError()

pyqttoolkit/scripting/script_template.py

@@ -0,0 +1,42 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# 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 this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from datetime import datetime
+
+from jinja2 import Environment
+
+class ScriptTemplate:
+    def __init__(self, template_string, name):
+        self._template_string = template_string
+        self._template_name = name
+    
+    def render(self, *args, **kwargs):
+        environment = Environment()
+        environment.globals.update(**self._get_globals())
+        template = environment.from_string(self._template_string)
+        return template.render(*args, **kwargs)
+    
+    def _get_globals(self):
+        return {
+            'zip': zip,
+            'len': len,
+            'template_name': self._template_name,
+            'now': datetime.now().strftime('%Y-%m-%d %I:%M'),
+            'indent': self._indent
+        }
+    
+    def _indent(self, level):
+        return '    ' * level

pyqttoolkit/services/__init__.py

@@ -0,0 +1,32 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# 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 this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+""":mod:`services`
+Defines classes and functions that provide services to the models of the application
+"""
+from .task_runner import TaskRunner
+from .message_board import MessageBoard, MessageArgs, MessageType, MessageResponse
+from .module_service import ModuleService
+from .tool_window_service import ToolWindowService
+from .link_manager import LinkManager, IncompatibleWidgets
+from .email import EmailService
+from .event_registry import EventRegistry, EventTypes
+from .object_converter import ObjectConverter, DictConverter
+from .autosave import Autosave
+from .hotkey_manager import HotkeyManager, HotkeyEvents
+from .theme_manager import ThemeManager
+from .project_updater import ProjectUpdater
+from .file_dialog import FileDialogService

pyqttoolkit/services/autosave.py

@@ -0,0 +1,41 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# 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 this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+from PyQt5.QtCore import QTimer, QObject
+#pylint: enable=no-name-in-module
+
+
+class Autosave(QObject):
+    def __init__(self, save_function, filename, interval=30000):
+        QObject.__init__(self)
+        self._save_function = save_function
+        self._timer = QTimer()
+        self._interval = interval
+        self._timer.timeout.connect(self._save)
+        self._filename = filename
+    
+    @property
+    def filename(self):
+        return self._filename
+    
+    def start(self):
+        self._timer.start(self._interval)
+    
+    def stop(self):
+        self._timer.stop()
+    
+    def _save(self):
+        self._save_function(self._filename)

pyqttoolkit/services/email.py

@@ -0,0 +1,25 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# 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 this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+"""
+http://code.activestate.com/recipes/511443-cross-platform-startfile-and-mailto-functions/
+"""
+import os
+
+class EmailService:
+    def send_mail(self, address, subject, body, attachements=None):
+        mailto_string = f'mailto:{address}?subject={subject}&body={body[:2000]}'
+        os.startfile(mailto_string)

pyqttoolkit/services/event_registry.py

@@ -0,0 +1,52 @@
+# pyqttoolkit
+# Copyright (C) 2018-2019, Simmovation Ltd.
+#
+# 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 this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
+class EventTypes:
+    application_closing = 'application_closing'
+    opening_project = 'opening_project'
+    importing_project = 'importing_project'
+    save_requested = 'save_requested'
+    close_project_requested = 'close_project_requested'
+    project_closed = 'project_closed'
+    save_dialog_finished = 'save_dialog_finished'
+
+class FutureConnector:
+    def __init__(self):
+        self._handlers = []
+    
+    def connect(self, handler):
+        self._handlers.append(handler)
+    
+    def register(self, event):
+        for h in self._handlers:
+            event.connect(h)
+
+class EventRegistry:
+    def __init__(self):
+        self._events = {}
+        self._future_events = {}
+    
+    def register(self, type_, event):
+        self._events[type_] = event
+        if type_ in self._future_events:
+            self._future_events[type_].register(event)
+    
+    def event(self, type_):
+        event = self._events.get(type_)
+        if not event:
+            return self._future_events.setdefault(type_, FutureConnector())
+        else:
+            return event