Python comm.Comm类代码示例

    def open(self):
        """Open a comm to the frontend if one isn't already open."""
        if self.comm is None:
            if self._model_id is None:
                self.comm = Comm(target_name=self._model_name)
                self._model_id = self.model_id
            else:
                self.comm = Comm(target_name=self._model_name, comm_id=self._model_id)
            self.comm.on_msg(self._handle_msg)
            Widget.widgets[self.model_id] = self

            # first update
            self.send_state()

 def start(self):
     try:
         self.comm = Comm('matplotlib', data={'id': self.uuid})
     except AttributeError:
         raise RuntimeError('Unable to create an IPython notebook Comm '
                            'instance. Are you in the IPython notebook?')
     self.comm.on_msg(self.on_message)
     self.comm.on_close(lambda close_message: self.manager.clearup_closed())

 def open(self):
     """Open a comm to the frontend if one isn't already open."""
     if self.comm is None:
         args = dict(
             target_name="ipython.widget", data={"model_name": self._model_name, "model_module": self._model_module}
         )
         if self._model_id is not None:
             args["comm_id"] = self._model_id
         self.comm = Comm(**args)

 def open(self):
     """Open a comm to the frontend if one isn't already open."""
     if self.comm is None:
         args = dict(target_name='ipython.widget',
                     data={'model_name': self._model_name,
                           'model_module': self._model_module})
         if self._model_id is not None:
             args['comm_id'] = self._model_id
         self.comm = Comm(**args)

    def __init__(self, session=None, json=None, auth=None):
        self.session = session
        self.id = json.get('id')
        self.auth = auth

        if self.session.lgn.ipython_enabled:
            from IPython.kernel.comm import Comm
            self.comm = Comm('lightning', {'id': self.id})
            self.comm_handlers = {}
            self.comm.on_msg(self._handle_comm_message)

 def __init__(self, manager):
     self.supports_binary = None
     self.manager = manager
     self.uuid = str(uuid())
     display(HTML("<div id=%r></div>" % self.uuid))
     try:
         self.comm = Comm('matplotlib', data={'id': self.uuid})
     except AttributeError:
         raise RuntimeError('Unable to create an IPython notebook Comm '
                            'instance. Are you in the IPython notebook?')
     self.comm.on_msg(self.on_message)

class CommSocket(object):
    """
    Manages the Comm connection between IPython and the browser (client).

    Comms are 2 way, with the CommSocket being able to publish a message
    via the send_json method, and handle a message with on_message. On the
    JS side figure.send_message and figure.ws.onmessage do the sending and
    receiving respectively.

    """
    def __init__(self, manager):
        self.supports_binary = None
        self.manager = manager
        self.uuid = str(uuid())
        display(HTML("<div id=%r></div>" % self.uuid))
        try:
            self.comm = Comm('matplotlib', data={'id': self.uuid})
        except AttributeError:
            raise RuntimeError('Unable to create an IPython notebook Comm '
                               'instance. Are you in the IPython notebook?')
        self.comm.on_msg(self.on_message)

    def on_close(self):
        # When the socket is closed, deregister the websocket with
        # the FigureManager.
        if self.comm in self.manager.web_sockets:
            self.manager.remove_web_socket(self)
        self.comm.close()

    def send_json(self, content):
        self.comm.send({'data': json.dumps(content)})

    def send_binary(self, blob):
        # The comm is ascii, so we always send the image in base64
        # encoded data URL form.
        data_uri = "data:image/png;base64,{0}".format(b64encode(blob))
        self.comm.send({'data': data_uri})

    def on_message(self, message):
        # The 'supports_binary' message is relevant to the
        # websocket itself.  The other messages get passed along
        # to matplotlib as-is.

        # Every message has a "type" and a "figure_id".
        message = json.loads(message['content']['data'])
        if message['type'] == 'closing':
            self.on_close()
        elif message['type'] == 'supports_binary':
            self.supports_binary = message['value']
        else:
            self.manager.handle_json(message)

    def __init__(self):
        """Constructor"""
        self._calls = 0
        self._callbacks = {}

        # Push the Javascript to the front-end.
        with open(os.path.join(os.path.split(__file__)[0], 'backend_context.js'), 'r') as f:
                display(Javascript(data=f.read()))

        # Open communication with the front-end.
        self._comm = Comm(target_name='BrowserContext')
        self._comm.on_msg(self._on_msg)

    def comm(self):
        """Gets the Comm associated with this widget.

        If a Comm doesn't exist yet, a Comm will be created automagically."""
        if self._comm is None:
            # Create a comm.
            self._comm = Comm(target_name=self._model_name)
            self._comm.on_msg(self._handle_msg)
            Widget.widgets[self.model_id] = self

            # first update
            self.send_state()
        return self._comm

    def open(self):
        """Open a comm to the frontend if one isn't already open."""
        if self.comm is None:
            args = dict(target_name='ipython.widget', data={ 'model_name': self._model_name })
            if self._model_id is not None:
                args['comm_id'] = self._model_id
            self.comm = Comm(**args)
            self._model_id = self.model_id
            
            self.comm.on_msg(self._handle_msg)
            Widget.widgets[self.model_id] = self

            # first update
            self.send_state()

class CustomCommSocket(CommSocket):
    """
    CustomCommSocket provides communication between the IPython
    kernel and a matplotlib canvas element in the notebook.
    A CustomCommSocket is required to delay communication
    between the kernel and the canvas element until the widget
    has been rendered in the notebook.
    """

    def __init__(self, manager):
        self.supports_binary = None
        self.manager = manager
        self.uuid = str(uuid.uuid4())
        self.html = "<div id=%r></div>" % self.uuid

    def start(self):
        try:
            self.comm = Comm('matplotlib', data={'id': self.uuid})
        except AttributeError:
            raise RuntimeError('Unable to create an IPython notebook Comm '
                               'instance. Are you in the IPython notebook?')
        self.comm.on_msg(self.on_message)
        self.comm.on_close(lambda close_message: self.manager.clearup_closed())

    def __init__(self, manager):
        self.supports_binary = None
        self.manager = manager
        self.uuid = str(uuid())
        # Publish an output area with a unique ID. The javascript can then
        # hook into this area.
        display(HTML("<div id=%r></div>" % self.uuid))
        try:
            self.comm = Comm('matplotlib', data={'id': self.uuid})
        except AttributeError:
            raise RuntimeError('Unable to create an IPython notebook Comm '
                               'instance. Are you in the IPython notebook?')
        self.comm.on_msg(self.on_message)

        manager = self.manager
        self.comm.on_close(lambda close_message: manager.clearup_closed())

    def show(self):
        from jinja2 import Template
        from IPython.core.display import display, HTML
        from IPython.kernel.comm import Comm

        path = os.path.abspath(os.path.join(os.path.dirname(__file__), "templates/template.html"))
        template = Template(open(path).read())
        css = str(self.css).replace("{", "").replace("}", "").replace(",", ";").replace("\'", "")

        html = template.render(**{
            "canvas_id": self.uuid,
            "svg_style": css
        })

        display(HTML(html))
        self.comm = Comm("Draw")

        if self.loop_func is not None:
            self.begin()
        else:
            self.send()

class Widget(LoggingConfigurable):
    #-------------------------------------------------------------------------
    # Class attributes
    #-------------------------------------------------------------------------
    _widget_construction_callback = None
    widgets = {}
    widget_types = {}

    @staticmethod
    def on_widget_constructed(callback):
        """Registers a callback to be called when a widget is constructed.

        The callback must have the following signature:
        callback(widget)"""
        Widget._widget_construction_callback = callback

    @staticmethod
    def _call_widget_constructed(widget):
        """Static method, called when a widget is constructed."""
        if Widget._widget_construction_callback is not None and callable(Widget._widget_construction_callback):
            Widget._widget_construction_callback(widget)

    @staticmethod
    def handle_comm_opened(comm, msg):
        """Static method, called when a widget is constructed."""
        widget_class = import_item(msg['content']['data']['widget_class'])
        widget = widget_class(comm=comm)


    #-------------------------------------------------------------------------
    # Traits
    #-------------------------------------------------------------------------
    _model_module = Unicode(None, allow_none=True, help="""A requirejs module name
        in which to find _model_name. If empty, look in the global registry.""")
    _model_name = Unicode('WidgetModel', help="""Name of the backbone model 
        registered in the front-end to create and sync this widget with.""")
    _view_module = Unicode(help="""A requirejs module in which to find _view_name.
        If empty, look in the global registry.""", sync=True)
    _view_name = Unicode(None, allow_none=True, help="""Default view registered in the front-end
        to use to represent the widget.""", sync=True)
    comm = Instance('IPython.kernel.comm.Comm')
    
    msg_throttle = Int(3, sync=True, help="""Maximum number of msgs the 
        front-end can send before receiving an idle msg from the back-end.""")
    
    version = Int(0, sync=True, help="""Widget's version""")
    keys = List()
    def _keys_default(self):
        return [name for name in self.traits(sync=True)]
    
    _property_lock = Tuple((None, None))
    _send_state_lock = Int(0)
    _states_to_send = Set(allow_none=False)
    _display_callbacks = Instance(CallbackDispatcher, ())
    _msg_callbacks = Instance(CallbackDispatcher, ())
    
    #-------------------------------------------------------------------------
    # (Con/de)structor
    #-------------------------------------------------------------------------
    def __init__(self, **kwargs):
        """Public constructor"""
        self._model_id = kwargs.pop('model_id', None)
        super(Widget, self).__init__(**kwargs)

        Widget._call_widget_constructed(self)
        self.open()

    def __del__(self):
        """Object disposal"""
        self.close()

    #-------------------------------------------------------------------------
    # Properties
    #-------------------------------------------------------------------------

    def open(self):
        """Open a comm to the frontend if one isn't already open."""
        if self.comm is None:
            args = dict(target_name='ipython.widget',
                        data={'model_name': self._model_name,
                              'model_module': self._model_module})
            if self._model_id is not None:
                args['comm_id'] = self._model_id
            self.comm = Comm(**args)

    def _comm_changed(self, name, new):
        """Called when the comm is changed."""
        if new is None:
            return
        self._model_id = self.model_id
        
        self.comm.on_msg(self._handle_msg)
        Widget.widgets[self.model_id] = self
        
        # first update
        self.send_state()

    @property
    def model_id(self):
        """Gets the model id of this widget.
#.........这里部分代码省略.........

class Canvas(object):
    def __init__(self):
        self.uuid = "canvas" + str(uuid4())
        self.css = {
            "width": "500px",
            "height": "500px",
            "background-color": "white"
        }
        self.loop_func = None
        self.interval = 0.1
        self.time = 0
        self.stop = False
        self.stack = []

    def begin(self):
        def func():
            self.loop_func(self.time)
            self.send()
            self.time += 1
            if not self.stop:
                timer = Timer(self.interval, func)
                timer.start()
        func()
    
    def show(self):
        from jinja2 import Template
        from IPython.core.display import display, HTML
        from IPython.kernel.comm import Comm

        path = os.path.abspath(os.path.join(os.path.dirname(__file__), "templates/template.html"))
        template = Template(open(path).read())
        css = str(self.css).replace("{", "").replace("}", "").replace(",", ";").replace("\'", "")

        html = template.render(**{
            "canvas_id": self.uuid,
            "svg_style": css
        })

        display(HTML(html))
        self.comm = Comm("Draw")

        if self.loop_func is not None:
            self.begin()
        else:
            self.send()

    def add(self, obj):
        import re
        r = re.compile(r"__.*__")
        for attr in dir(obj):
            m = getattr(obj, str(attr))
            if callable(m) and not r.match(str(attr)):
                def make_func():
                    m_ = m
                    def func(*args, **kw):
                        self.stack.append(("update", obj))
                        return m_(*args, **kw)
                    return func

                setattr(obj, str(attr), make_func())

        self.stack.append(("append", obj))

    def send(self):
        self.comm.send({
            "canvas_id": self.uuid,
            "queue": [{
                "method": s[0],
                "type": s[1].__class__.__name__.lower(),
                "attr": s[1].attr,
                "selector_id": s[1].uuid
            } for s in self.stack]
        })
        self.stack = []

    def loop(self, func):
        self.loop_func = func

    def width(self, val):
        self.css["width"] = str(val) + "px"

    def height(self, val):
        self.css["height"] = str(val) + "px"

    def background_color(self, val):
        self.css["background-color"] = val