tryton 7.4.8__py3-none-any.whl → 7.6.0__py3-none-any.whl

tryton/__init__.py

@@ -1,6 +1,6 @@
 # This file is part of Tryton.  The COPYRIGHT file at the top level of
 # this repository contains the full copyright notices and license terms.
-__version__ = "7.4.8"
+__version__ = "7.6.0"
 import locale
 
 import gi

tryton/bus.py

@@ -7,6 +7,7 @@ import socket
 import threading
 import time
 import uuid
+from collections import defaultdict
 from urllib.error import HTTPError
 from urllib.request import Request, urlopen
 
@@ -18,82 +19,125 @@ from tryton.jsonrpc import object_hook
 logger = logging.getLogger(__name__)
 
 
-ID = str(uuid.uuid4())
-CHANNELS = [
-    'client:%s' % ID,
-    ]
+class Bus:
 
+    ID = str(uuid.uuid4())
+    current_thread = None
+    channel_actions = defaultdict(list)
+    listening = False
 
-def listen(connection):
-    if not CONFIG['thread']:
-        return
-    listener = threading.Thread(
-        target=_listen, args=(connection,), daemon=True)
-    listener.start()
-
-
-def _listen(connection):
-    bus_timeout = CONFIG['client.bus_timeout']
-    session = connection.session
-    authorization = base64.b64encode(session.encode('utf-8'))
-    headers = {
-        'Content-Type': 'application/json',
-        'Authorization': b'Session ' + authorization,
-        }
-
-    wait = 1
-    last_message = None
-    url = None
-    while connection.session == session:
-        if url is None:
-            if connection.url is None:
-                time.sleep(1)
-                continue
-            url = connection.url + '/bus'
-        request = Request(url,
-            data=json.dumps({
-                    'last_message': last_message,
-                    'channels': CHANNELS,
-                    }).encode('utf-8'),
-            headers=headers)
-        logger.info('poll channels %s with last message %s',
-            CHANNELS, last_message)
-        try:
-            response = urlopen(request, timeout=bus_timeout)
-            wait = 1
-        except socket.timeout:
-            wait = 1
-            continue
-        except Exception as error:
-            if isinstance(error, HTTPError):
-                if error.code in (301, 302, 303, 307, 308):
-                    url = error.headers.get('Location')
+    @classmethod
+    def listen(cls, connection):
+        if not CONFIG['thread']:
+            return
+        listener = threading.Thread(
+            target=cls._listen, args=(connection,), daemon=True)
+        listener.start()
+        cls.current_thread = listener.ident
+
+    @classmethod
+    def _listen(cls, connection):
+        bus_timeout = CONFIG['client.bus_timeout']
+        session = connection.session
+        authorization = base64.b64encode(session.encode('utf-8'))
+        headers = {
+            'Content-Type': 'application/json',
+            'Authorization': b'Session ' + authorization,
+            }
+
+        thread_id = threading.get_ident()
+        wait = 1
+        last_message = None
+        url = None
+        while connection.session == session:
+            if url is None:
+                if connection.url is None:
+                    time.sleep(1)
                     continue
-                elif error.code == 501:
-                    logger.info("Bus not supported")
+                url = connection.url + '/bus'
+            cls.listening = True
+
+            channels = list(cls.channel_actions)
+            request = Request(url,
+                data=json.dumps({
+                        'last_message': last_message,
+                        'channels': channels,
+                        }).encode('utf-8'),
+                headers=headers)
+            logger.info('poll channels %s with last message %s',
+                channels, last_message)
+            try:
+                response = urlopen(request, timeout=bus_timeout)
+                wait = 1
+            except socket.timeout:
+                wait = 1
+                continue
+            except Exception as error:
+                if thread_id != cls.current_thread:
                     break
-            logger.error(
-                "An exception occurred while connecting to the bus. "
-                "Sleeping for %s seconds",
-                wait, exc_info=error)
-            time.sleep(min(wait, bus_timeout))
-            wait *= 2
-            continue
+                if isinstance(error, HTTPError):
+                    if error.code in (301, 302, 303, 307, 308):
+                        url = error.headers.get('Location')
+                        continue
+                    elif error.code == 501:
+                        logger.info("Bus not supported")
+                        break
+                logger.error(
+                    "An exception occurred while connecting to the bus. "
+                    "Sleeping for %s seconds",
+                    wait, exc_info=error)
+                cls.listening = False
+                time.sleep(min(wait, bus_timeout))
+                wait *= 2
+                continue
 
-        if connection.session != session:
-            break
+            if connection.session != session:
+                break
+            if thread_id != cls.current_thread:
+                break
 
-        data = json.loads(response.read(), object_hook=object_hook)
-        if data['message']:
-            last_message = data['message']['message_id']
-            GLib.idle_add(handle, data['message'])
+            data = json.loads(response.read(), object_hook=object_hook)
+            if data['message']:
+                last_message = data['message']['message_id']
+                GLib.idle_add(cls.handle, data['channel'], data['message'])
+        cls.listening = False
 
+    @classmethod
+    def handle(cls, channel, message):
+        for callback in cls.channel_actions[channel]:
+            callback(message)
 
-def handle(message):
-    from tryton.gui.main import Main
+    @classmethod
+    def register(cls, channel, function):
+        from tryton import rpc
+
+        restart = channel not in cls.channel_actions
+        cls.channel_actions[channel].append(function)
+        if restart:
+            # We can not really abort a thread, so we will just start a new one
+            # and ignore the result of the one already running
+            Bus.listen(rpc.CONNECTION)
 
+    @classmethod
+    def unregister(cls, channel, function):
+        try:
+            cls.channel_actions[channel].remove(function)
+        except ValueError:
+            pass
+
+        if not cls.channel_actions[channel]:
+            del cls.channel_actions[channel]
+
+
+def popup_notification(message):
+    if message['type'] != 'notification':
+        return
+
+    from tryton.gui.main import Main
     app = Main()
-    if message['type'] == 'notification':
-        app.show_notification(
-            message.get('title', ''), message.get('body', ''),
-            message.get('priority', 1))
+    app.show_notification(
+        message.get('title', ''), message.get('body', ''),
+        message.get('priority', 1))
+
+
+Bus.register(f'client:{Bus.ID}', popup_notification)

tryton/chat.py

@@ -0,0 +1,179 @@
+# This file is part of Tryton.  The COPYRIGHT file at the top level of
+# this repository contains the full copyright notices and license terms.
+import gettext
+
+from gi.repository import Gdk, Gio, GObject, Gtk
+
+from tryton import common, rpc
+from tryton.bus import Bus
+
+_ = gettext.gettext
+
+
+class MessageItem(GObject.GObject):
+
+    def __init__(self, message):
+        super().__init__()
+        self.message = message
+
+
+class MessageList(GObject.GObject, Gio.ListModel):
+
+    def __init__(self):
+        super().__init__()
+        self._messages = []
+        self._items = {}
+
+    def do_get_item(self, position):
+        if position >= len(self._messages):
+            return None
+        message = self._messages[position]
+        if message['id'] not in self._items:
+            self._items[message['id']] = MessageItem(message)
+        return self._items[message['id']]
+
+    def do_get_item_type(self):
+        return MessageItem
+
+    def do_get_n_items(self):
+        return len(self._messages)
+
+    def clear(self):
+        self.emit('items-changed', 0, len(self._messages), 0)
+        self._messages = []
+        self._items = {}
+
+    def append(self, message):
+        self._messages.append(message)
+        self.emit('items-changed', len(self._messages) - 1, 0, 1)
+
+
+class Chat:
+
+    def __init__(self, record):
+        self.record = record
+        Bus.register(f"chat:{self.record}", self.notify)
+        self.widget = self.__build()
+
+    def unregister(self):
+        Bus.unregister(f"chat:{self.record}", self.notify)
+
+    def send_message(self, message, internal):
+        rpc.execute(
+            'model', 'ir.chat.channel', 'post', self.record, message,
+            'internal' if internal else 'public', rpc.CONTEXT)
+
+    def get_messages(self):
+        return rpc.execute(
+            'model', 'ir.chat.channel', 'get', self.record, rpc.CONTEXT)
+
+    def notify(self, message):
+        self.refresh()
+
+    def refresh(self):
+        self._messages.clear()
+        for post in self.get_messages():
+            self._messages.append(post)
+        self.widget.show_all()
+
+        def scroll_to_bottom(*args):
+            self._messages_sw.disconnect(signal_id)
+            vadj = self._messages_sw.get_vadjustment()
+            vadj.props.value = vadj.get_upper()
+        signal_id = self._messages_sw.connect(
+            'size-allocate', scroll_to_bottom)
+
+    def __build(self):
+        widget = Gtk.VBox()
+        widget.set_spacing(3)
+
+        def _submit(button):
+            buffer = input_.get_buffer()
+            self.send_message(
+                buffer.get_text(
+                    buffer.get_start_iter(), buffer.get_end_iter(), False),
+                internal.get_active())
+            buffer.set_text('')
+            if not Bus.listening:
+                self.refresh()
+
+        def _keypress(entry, event):
+            if (event.state & Gdk.ModifierType.CONTROL_MASK
+                    and event.keyval == Gdk.KEY_Return):
+                _submit(None)
+                return True
+
+        self._messages = MessageList()
+        chat_messages = Gtk.ListBox.new()
+        chat_messages.props.activate_on_single_click = False
+        chat_messages.set_selection_mode(Gtk.SelectionMode.NONE)
+        chat_messages.bind_model(self._messages, self.create_message)
+        self._messages_sw = scrolledwindow = Gtk.ScrolledWindow()
+        viewport = Gtk.Viewport()
+        viewport.add(chat_messages)
+        viewport.set_valign(Gtk.Align.END)
+        scrolledwindow.set_shadow_type(Gtk.ShadowType.NONE)
+        scrolledwindow.set_policy(
+            Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
+        scrolledwindow.add(viewport)
+        widget.pack_start(scrolledwindow, True, True, 0)
+
+        input_ = Gtk.TextView()
+        input_.connect('key-press-event', _keypress)
+        input_.set_size_request(-1, 100)
+        widget.pack_start(input_, False, True, 0)
+
+        internal = Gtk.CheckButton.new_with_mnemonic(
+            _("Make this an _internal message"))
+        widget.pack_start(internal, False, True, 0)
+
+        submit = Gtk.Button.new_with_label(_("Send"))
+        submit.connect('clicked', _submit)
+        widget.pack_start(submit, False, False, 0)
+
+        return widget
+
+    def create_message(self, item):
+        message = item.message
+
+        row = Gtk.ListBoxRow()
+        row.set_selectable(False)
+        row.set_margin_top(5)
+
+        hbox = Gtk.HBox(spacing=10)
+        row.add(hbox)
+
+        if avatar_url := message.get('avatar_url'):
+            image = Gtk.Image()
+            pixbuf = common.IconFactory.get_pixbuf_url(
+                avatar_url, size=32, size_param='s',
+                callback=image.set_from_pixbuf)
+            image.set_from_pixbuf(pixbuf)
+            image.set_valign(Gtk.Align.START)
+            hbox.pack_start(image, False, False, 0)
+
+        bubble = Gtk.VBox()
+        hbox.pack_end(bubble, True, True, 0)
+
+        author = Gtk.Label(label=message['author'])
+        author.set_xalign(0)
+        author.get_style_context().add_class('dim')
+        timestamp = Gtk.Label(label=message['timestamp'].strftime('%x %X'))
+        timestamp.set_xalign(1)
+        timestamp.get_style_context().add_class('dim')
+
+        meta = Gtk.HBox()
+        meta.pack_start(author, True, True, 0)
+        meta.pack_end(timestamp, False, False, 0)
+
+        content = Gtk.Label(label=message['content'])
+        content.set_xalign(0)
+        content.set_line_wrap(True)
+        content.set_selectable(True)
+        content.get_style_context().add_class(
+            f"chat-content-{message['audience']}")
+
+        bubble.pack_start(meta, False, False, 0)
+        bubble.pack_start(content, False, False, 0)
+
+        return row

tryton/client.py

@@ -33,6 +33,13 @@ def main():
     label.warning {
         color: @warning_color;
     }
+    label.dim {
+        font-size: smaller;
+        font-weight: lighter;
+    }
+    .chat-content-internal {
+        font-weight: lighter;
+    }
     .window-title, .wizard-title {
         font-size: large;
         font-weight: bold;

tryton/common/__init__.py

@@ -2,17 +2,18 @@
 # this repository contains the full copyright notices and license terms.
 from . import timedelta
 from .common import (
-    COLOR_SCHEMES, MODELACCESS, MODELHISTORY, MODELNAME, MODELNOTIFICATION,
-    TRYTON_ICON, VIEW_SEARCH, IconFactory, Logout, RPCContextReload,
-    RPCException, RPCExecute, RPCProgress, Tooltips, apply_label_attributes,
-    ask, check_version, concurrency, data2pixbuf, date_format, ellipsize,
-    error, file_open, file_selection, file_write, filter_domain,
-    generateColorscheme, get_align, get_credentials, get_gdk_backend,
-    get_hostname, get_port, get_sensible_widget, get_toplevel_window, hex2rgb,
-    highlight_rgb, humanize, idle_add, mailto, message, node_attributes,
-    open_documentation, play_sound, process_exception, resize_pixbuf,
-    selection, setup_window, slugify, sur, sur_3b, timezoned_date, to_xml,
-    untimezoned_date, url_open, userwarning, warning)
+    COLOR_SCHEMES, MODELACCESS, MODELCHAT, MODELHISTORY, MODELNAME,
+    MODELNOTIFICATION, TRYTON_ICON, VIEW_SEARCH, IconFactory, Logout,
+    RPCContextReload, RPCException, RPCExecute, RPCProgress, SolidColorFactory,
+    Tooltips, apply_label_attributes, ask, check_version, concurrency,
+    data2pixbuf, date_format, ellipsize, error, file_open, file_selection,
+    file_write, filter_domain, generateColorscheme, get_align, get_credentials,
+    get_gdk_backend, get_hostname, get_monitor_size, get_port,
+    get_sensible_widget, get_toplevel_window, hex2rgb, highlight_rgb, humanize,
+    idle_add, mailto, message, node_attributes, open_documentation, play_sound,
+    process_exception, resize_pixbuf, selection, setup_window, slugify, sur,
+    sur_3b, timezoned_date, to_xml, untimezoned_date, url_open, userwarning,
+    warning)
 from .domain_inversion import (
     concat, domain_inversion, eval_domain, extract_reference_models,
     filter_leaf, inverse_leaf, localize_domain, merge,
@@ -28,10 +29,12 @@ __all__ = [
     MODELHISTORY,
     MODELNAME,
     MODELNOTIFICATION,
+    MODELCHAT,
     RPCContextReload,
     RPCException,
     RPCExecute,
     RPCProgress,
+    SolidColorFactory,
     TRYTON_ICON,
     Tooltips,
     VIEW_SEARCH,
@@ -57,6 +60,7 @@ __all__ = [
     get_credentials,
     get_gdk_backend,
     get_hostname,
+    get_monitor_size,
     get_port,
     get_sensible_widget,
     get_toplevel_window,

tryton/common/button.py

@@ -14,7 +14,7 @@ class Button(Gtk.Button):
     def __init__(self, attrs=None):
         self.attrs = attrs or {}
         self.label = '_' + attrs.get('string', '').replace('_', '__')
-        super(Button, self).__init__(label=self.label, stock=None,
+        super().__init__(label=self.label, stock=None,
             use_underline=True)
         self._set_icon(attrs.get('icon'))
 

tryton/common/cellrendererfloat.py

@@ -10,7 +10,7 @@ from .cellrendererinteger import CellRendererInteger
 class CellRendererFloat(CellRendererInteger):
 
     def __init__(self):
-        super(CellRendererFloat, self).__init__()
+        super().__init__()
         self.digits = None
         self.monetary = False
         self.convert = float

tryton/common/cellrenderertext.py

@@ -6,7 +6,7 @@ from gi.repository import GObject, Gtk
 class CellRendererText(Gtk.CellRendererText):
 
     def __init__(self):
-        super(CellRendererText, self).__init__()
+        super().__init__()
         self.connect('editing-started', self.__class__.on_editing_started)
 
     def on_editing_started(self, editable, path):
@@ -16,7 +16,7 @@ class CellRendererText(Gtk.CellRendererText):
 class CellRendererTextCompletion(CellRendererText):
 
     def __init__(self, set_completion):
-        super(CellRendererTextCompletion, self).__init__()
+        super().__init__()
         self.set_completion = set_completion
 
     def on_editing_started(self, editable, path):