osbot-utils 1.7.7__py3-none-any.whl

osbot_utils/helpers/html/Dict_To_Css.py

@@ -0,0 +1,20 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+
+
+class Dict_To_Css(Kwargs_To_Self):
+    css: dict
+
+
+    def add_css_entry(self, selector, data):
+        self.css[selector] = data
+        return self
+
+    def convert(self, indent=''):
+        css_lines = []                                                          # List to hold each line of CSS
+        for selector, properties in self.css.items():
+            css_line = f"{indent}{selector} {{"                                 # Start the selector line
+            for prop, value in properties.items():                              # Add each property and value to the selector's CSS
+                css_line += f"\n{indent}    {prop}: {value};"
+            css_line += '\n' + indent + "}"                                     # Close the selector's CSS block
+            css_lines.append(css_line)                                          # Add the completed selector's CSS to the list
+        return "\n".join(css_lines)                                             # Join all selector CSS blocks with a newline and return

osbot_utils/helpers/html/Dict_To_Html.py

@@ -0,0 +1,59 @@
+
+HTML_SELF_CLOSING_TAGS = {'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'}
+
+class Dict_To_Html:
+    def __init__(self, root):
+        # Define a list of self-closing tags
+        self.self_closing_tags =HTML_SELF_CLOSING_TAGS # {'area', 'base', 'br', 'col', 'command', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr'}
+        self.root = root
+
+    def convert(self):
+        return self.convert_element(self.root, 0)               # Start conversion with the root element and initial indentation level 0
+
+    def convert_attrs(self, attrs):
+        attrs_str_parts = []                                                # List to hold each attribute's string representation
+        for key, value in attrs.items():
+            if '"' in value:                                                # Check if the attribute value contains double quotes
+                escaped_value = """.join(value.split("\""))            # If so, escape double quotes and format the attribute string
+                attr_str      = f'{key}="{escaped_value}"'
+            else:
+                attr_str = f'{key}="{value}"'                               # If not, simply format the attribute string
+            attrs_str_parts.append(attr_str)
+
+        attrs_str = ' '.join(attrs_str_parts)                               # Join the parts into the final attributes string
+
+        if attrs_str:
+            attrs_str = " " + attrs_str                                     # Prepend a space if there are attributes
+        return attrs_str
+
+    def convert_element(self, element, indent_level):
+        """Recursively converts a dictionary to an HTML string with indentation."""
+        tag      = element.get("tag")
+        attrs    = element.get("attrs", {})
+        children = element.get("children", [])
+        data     = element.get("data", "")
+
+        attrs_str = self.convert_attrs(attrs)                           # Convert attributes dictionary to a string
+        indent = "    " * indent_level                                  # Indentation for the current level, assuming 4 spaces per indent level
+
+        if tag in self.self_closing_tags:                               # Check if the tag is self-closing
+            return f"{indent}<{tag}{attrs_str} />\n"
+
+        html = f"{indent}<{tag}{attrs_str}>"                            # Opening tag with indentation
+        if not data:
+            html += '\n'
+
+        for child in children:                                          # Process children with incremented indent level
+            html += self.convert_element(child, indent_level + 1)
+
+        if data:                                                        # Add data if present
+            html += data
+
+        if children:                                                    # Closing tag for non-self-closing tags, with indentation
+            html += f"{indent}</{tag}>\n"                               # Add closing tag on a new line if there are children
+        elif data:
+            html += f"</{tag}>\n"
+        else:                                                           # Place closing tag directly after opening tag if there are no children or data
+            html = f"{indent}<{tag}{attrs_str}></{tag}>\n"
+
+        return html

osbot_utils/helpers/html/Dict_To_Tags.py

@@ -0,0 +1,88 @@
+from osbot_utils.helpers.html.Dict_To_Html import HTML_SELF_CLOSING_TAGS
+from osbot_utils.helpers.html.Tag__Base import Tag__Base
+from osbot_utils.helpers.html.Tag__Body import Tag__Body
+from osbot_utils.helpers.html.Tag__Head import Tag__Head
+from osbot_utils.helpers.html.Tag__Html import Tag__Html
+from osbot_utils.helpers.html.Tag__Link import Tag__Link
+from osbot_utils.utils.Dev import pprint
+
+
+class Dict_To_Tags:
+
+    def __init__(self, root):
+        self.root = root
+
+    def convert(self):
+        return self.convert_element(self.root)
+
+    def convert_element(self, element):
+        tag_name = element.get("tag"                )
+        attrs    = element.get("attrs"      , {}    )
+        children = element.get("children"   , []    )
+        data     = element.get("data"       , ""    )
+        if tag_name == 'html':
+            return self.convert_to__tag__html(element)
+        if tag_name == 'head':
+            return self.convert_to__tag__head(element)
+        if tag_name == 'link':
+            return self.convert_to__tag__link(element)
+
+    def convert_to__tag(self, target_tag, element, indent):
+        tag_name   = element.get("tag"                )
+        attrs      = element.get("attrs"      , {}    )
+        children   = element.get("children"   , []    )
+        data       = element.get("data"       , ''    )
+        end_tag    = tag_name not in HTML_SELF_CLOSING_TAGS
+        tag_indent = indent + 1
+        tag_kwargs  = dict(tag_name  = tag_name    ,
+                           attributes = attrs      ,
+                           end_tag    = end_tag    ,
+                           indent     = tag_indent ,
+                           inner_html = data       )
+        tag        = target_tag(**tag_kwargs)
+        for child in children:
+            child_tag = self.convert_to__tag(Tag__Base, child, tag_indent)
+            tag.elements.append(child_tag)
+
+        return tag
+
+    def convert_to__tag__head(self, element, indent):
+        attrs    = element.get("attrs"      , {}    )
+        children = element.get("children"   , []    )
+        print()
+        head_indent = indent+1
+        tag_head = Tag__Head(indent=head_indent, **attrs)
+        for child in children:
+            tag_name = child.get("tag"     )
+            data     = child.get("data", "")
+            if tag_name == 'title':
+                tag_head.title = data
+            elif tag_name == 'link':
+                tag_head.links.append(self.convert_to__tag__link(child))
+            elif tag_name == 'meta':
+                tag_head.elements.append((self.convert_to__tag(Tag__Base, child, indent=head_indent)))
+            elif tag_name == 'style':
+                tag_head.elements.append((self.convert_to__tag(Tag__Base, child, indent=head_indent)))      # todo: add proper roundtrip of css data into Tag__Style (which already exists)
+            else:
+                print(f'[convert_to__tag__head] Unknown tag: {tag_name}')
+        #pprint(tag_head.__locals__())
+        return tag_head
+
+    def convert_to__tag__html(self, element):
+        attrs    = element.get("attrs"      , {}    )
+        children = element.get("children"   , []    )
+        tag_html = Tag__Html(**attrs)
+        for child in children:
+            tag_name = child.get("tag" )
+            if tag_name == 'head':
+                tag_html.head = self.convert_to__tag__head(child, tag_html.indent)
+            elif tag_name == 'body':
+                tag_html.body = self.convert_to__tag(Tag__Body, child, tag_html.indent)
+            else:
+                print(f'unknown tag: {tag_name}')
+        return tag_html
+
+    def convert_to__tag__link(self, element):
+        attrs    = element.get("attrs", {})
+        tag_link = Tag__Link(**attrs)
+        return tag_link

osbot_utils/helpers/html/Html_To_Dict.py

@@ -0,0 +1,75 @@
+from html.parser import HTMLParser
+
+class Html_To_Dict(HTMLParser):
+    def __init__(self, html):
+        super().__init__()
+        self.root    = None            # No root initially
+        self.current = None         # No current node at the start
+        self.stack   = []             # Empty stack for hierarchy management
+        self.html    = html or ''
+
+    def convert(self):
+        self.feed(self.html)
+        return self.root
+
+    def handle_starttag(self, tag, attrs):
+        new_tag = {"tag": tag, "attrs": dict(attrs), "children": [], "data": ""}
+
+        if self.current is None:
+            # When the first tag is encountered, it becomes the root
+            self.root = new_tag
+            self.current = new_tag
+        else:
+            # Otherwise, append the new tag as a child of the current tag
+            self.current["children"].append(new_tag)
+
+        # Update the stack and current pointers
+        self.stack.append(new_tag)
+        self.current = new_tag
+
+    def handle_endtag(self, tag):
+        if len(self.stack) > 1:
+            self.stack.pop()
+            self.current = self.stack[-1]
+
+    def handle_data(self, data):
+        if data.strip():  # Ignore whitespace
+            if "data" in self.current:
+                self.current["data"] += data
+            else:
+                self.current["data"] = data
+
+    def print__generate_lines(self, node, indent="", last=True, is_root=True):
+        lines = []
+
+        prefix = "" if is_root else ("└── " if last else "├── ")
+
+        tag = node.get("tag")
+        attrs = node.get("attrs", {})
+        children = node.get("children", [])
+        attrs_str = ' '.join(f'{key}="{value}"' for key, value in attrs.items())
+        attrs_str = f' ({attrs_str})' if attrs_str else ''
+
+        lines.append(f"{indent}{prefix}{tag}{attrs_str}")
+
+        child_indent = indent + ("    " if last else "│   ")
+
+        for i, child in enumerate(children):
+            is_last = i == len(children) - 1
+            child_lines = self.print__generate_lines(child, indent=child_indent, last=is_last, is_root=False)
+            lines.extend(child_lines if isinstance(child_lines, list) else [child_lines])
+
+        return lines if is_root else "\n".join(lines)
+
+    def print(self, just_return_lines=False):
+        if self.root:
+            lines = self.print__generate_lines(self.root, is_root=True)
+            if just_return_lines:
+                return lines
+            else:
+                self.print__lines(lines)
+        return self
+
+    def print__lines(self, lines):
+        for line in lines:
+            print(line)

osbot_utils/helpers/html/Html_To_Tag.py

@@ -0,0 +1,20 @@
+from osbot_utils.helpers.html.Dict_To_Tags import Dict_To_Tags
+
+from osbot_utils.helpers.html.Html_To_Dict import Html_To_Dict
+
+
+class Html_To_Tag:
+
+    def __init__(self,html):
+        self.html_to_dict = Html_To_Dict(html)
+
+    def __enter__(self):
+        return self.convert()
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        return
+
+    def convert(self):
+        html_dict = self.html_to_dict.convert()
+        html_tag  = Dict_To_Tags(html_dict).convert()
+        return html_tag

osbot_utils/helpers/html/Tag__Base.py

@@ -0,0 +1,91 @@
+from collections import defaultdict
+
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.utils.Files import file_create
+
+INDENT_SIZE = 4
+
+class Tag__Base(Kwargs_To_Self):
+    attributes               : dict
+    elements                 : list
+    end_tag                  : bool = True
+    indent                   : int
+    tag_name                 : str
+    tag_classes              : list
+    inner_html               : str
+    new_line_before_elements : bool = True
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        #self.locked()                                   # lock the object so that it is not possible to add new attributes via normal assigment
+
+    def append(self, *elements):
+        self.elements.extend(elements)
+        return self
+
+    def attributes_values(self, *attributes_names):
+        attributes = {}
+        for attribute_name in attributes_names:
+            if hasattr(self, attribute_name):
+                attribute_value = getattr(self, attribute_name)
+                if attribute_value:
+                    attributes[attribute_name] = attribute_value
+        return attributes
+
+    def elements__by_tag_name(self):
+        result = defaultdict(list)
+        for element in self.elements:
+            result[element.tag_name].append(element)
+        return dict(result)
+
+    def elements__with_tag_name(self, tag_name):
+        return self.elements__by_tag_name().get(tag_name)
+
+    def save(self, file_path):
+        return file_create(file_path, self.render())
+
+    def render_attributes(self):
+        attributes = self.attributes.copy()
+        if self.tag_classes:
+            attributes['class'] = ' '.join(self.tag_classes)
+
+        html_attributes = ' '.join([f'{key}="{value}"' for key, value in attributes.items()])
+        return html_attributes
+
+    def render_element(self):
+        html_attributes = self.render_attributes()
+        html_elements   = self.render_elements()
+        element_indent  = " " * self.indent * INDENT_SIZE
+
+        html = f"{element_indent}<{self.tag_name}"
+        if html_attributes:
+            html += f" {html_attributes}"
+        if self.end_tag:
+            html += ">"
+            if self.inner_html:
+                html += self.inner_html
+            if html_elements:
+                if self.new_line_before_elements:
+                    html += "\n"
+                html += f"{html_elements}"
+                if self.new_line_before_elements:
+                    html += "\n"
+                html += element_indent
+            html += f"</{self.tag_name}>"
+        else:
+            html += "/>"
+
+        return html
+
+    def render_elements(self):
+        html_elements = ""
+        for index, element in enumerate(self.elements):
+            if index:
+                html_elements += '\n'
+            element.indent = self.indent + 1        # set the indent of the child element based on the current one
+            html_element = element.render()
+            html_elements += html_element
+        return html_elements
+
+    def render(self):
+        return self.render_element()

osbot_utils/helpers/html/Tag__Body.py

@@ -0,0 +1,5 @@
+from osbot_utils.helpers.html.Tag__Base import Tag__Base
+
+
+class Tag__Body(Tag__Base):
+    tag_name = 'body'

osbot_utils/helpers/html/Tag__Div.py

@@ -0,0 +1,5 @@
+from osbot_utils.helpers.html.Tag__Base import Tag__Base
+
+
+class Tag__Div(Tag__Base):
+    tag_name    = 'div'

osbot_utils/helpers/html/Tag__H.py

@@ -0,0 +1,9 @@
+from osbot_utils.helpers.html.Tag__Base import Tag__Base
+
+
+class Tag__H(Tag__Base):
+    def __init__(self, size, value):
+        tag_name     = f'h{size}'
+        inner_html   = value
+        init__kwargs = dict(tag_name=tag_name, inner_html=inner_html)
+        super().__init__(**init__kwargs)

osbot_utils/helpers/html/Tag__HR.py

@@ -0,0 +1,5 @@
+from osbot_utils.helpers.html.Tag__Base import Tag__Base
+
+
+class Tag__HR(Tag__Base):
+    tag_name    = 'hr'

osbot_utils/helpers/html/Tag__Head.py

@@ -0,0 +1,32 @@
+from osbot_utils.helpers.html.Tag__Base import Tag__Base
+from osbot_utils.helpers.html.Tag__Link import Tag__Link
+from osbot_utils.helpers.html.Tag__Style import Tag__Style
+from osbot_utils.utils.Dev import pprint
+
+
+class Tag__Head(Tag__Base):
+    title    : str
+    links    : list[Tag__Link]
+    meta     : list[Tag__Base]
+    style    : Tag__Style
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.tag_name = 'head'
+
+    def add_css_bootstrap(self):
+        link = Tag__Link(href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css", rel="stylesheet")
+        self.links.append(link)
+        return self
+
+    def render(self):
+        if self.title:
+            title_element = Tag__Base(tag_name='title', inner_html=self.title, indent=self.indent + 1)
+            self.elements.append(title_element)
+        for link in self.links:
+            link.indent  = self.indent + 1
+            self.elements.append(link)
+        if self.style.css():
+            self.elements.append(self.style)
+        html = self.render_element()
+        return html

osbot_utils/helpers/html/Tag__Html.py

@@ -0,0 +1,42 @@
+from osbot_utils.helpers.html.Tag__Base import Tag__Base
+from osbot_utils.helpers.html.Tag__Body import Tag__Body
+from osbot_utils.helpers.html.Tag__Head import Tag__Head
+from osbot_utils.utils.Misc import str_to_bytes
+
+ATTRIBUTES_NAMES__LINK = ['lang']
+
+
+class Tag__Html(Tag__Base):
+    doc_type: bool = True
+    body    : Tag__Body
+    head    : Tag__Head
+    lang    : str
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.head.indent = self.indent + 1
+        self.body.indent = self.indent + 1
+        self.tag_name    = 'html'
+
+    def render(self):
+        self.elements = [self.head, self.body]
+        self.attributes = self.attributes_values(*ATTRIBUTES_NAMES__LINK)
+        if self.doc_type:
+            html = "<!DOCTYPE html>\n"
+        else:
+            html = ""
+        attributes = {}
+        if self.lang:
+            attributes['lang'] = self.lang
+
+        html += self.render_element()
+        return html
+
+    def render_to_bytes(self):
+        return str_to_bytes(self.render())
+
+    def set_inner_html(self, value):
+        self.body.inner_html = value
+        return self
+
+

osbot_utils/helpers/html/Tag__Link.py

@@ -0,0 +1,17 @@
+from osbot_utils.helpers.html.Tag__Base import Tag__Base
+
+ATTRIBUTES_NAMES__LINK = ['href', 'rel', 'integrity',  'crossorigin']
+
+class Tag__Link(Tag__Base):
+    end_tag    : bool = False
+    tag_name   : str  = 'link'
+    crossorigin: str
+    href       : str
+    rel        : str
+    integrity  : str
+
+
+    def render(self):
+        self.attributes = self.attributes_values(*ATTRIBUTES_NAMES__LINK)
+
+        return self.render_element()

osbot_utils/helpers/html/Tag__Style.py

@@ -0,0 +1,25 @@
+from osbot_utils.helpers.html.Dict_To_Css import Dict_To_Css
+from osbot_utils.helpers.html.Tag__Base import Tag__Base, INDENT_SIZE
+
+
+class Tag__Style(Tag__Base):
+    tag_name    : str = 'style'
+    dict_to_css : Dict_To_Css
+
+    def add_css_entry(self, selector, data):
+        self.dict_to_css.add_css_entry(selector,data)
+        return self
+
+    def css(self):
+        return self.dict_to_css.css
+
+    def render(self):
+        if self.dict_to_css.css:
+            css_indent          = self.indent +1
+            css_indent_text     = " " * css_indent * INDENT_SIZE
+            element_indent_text = " " * self.indent * INDENT_SIZE
+            self.inner_html = '\n' + self.dict_to_css.convert(indent=css_indent_text) + '\n' + element_indent_text
+        return super().render()
+
+    def set_css(self, css):
+        self.dict_to_css.css = css

osbot_utils/helpers/pubsub/Event__Queue.py

@@ -0,0 +1,95 @@
+import time
+from enum import Enum
+from queue                                      import Queue, Empty
+from threading                                  import Thread
+from typing import Any
+
+from osbot_utils.helpers.pubsub.schemas.Schema__Event import Schema__Event
+from osbot_utils.helpers.pubsub.schemas.Schema__Event__Message import Schema__Event__Message
+from osbot_utils.utils                                import Misc
+from osbot_utils.base_classes.Kwargs_To_Self          import Kwargs_To_Self
+from osbot_utils.utils.Misc import random_text, wait_for, timestamp_utc_now, random_guid
+
+QUEUE_WAIT_TIMEOUT  = 1.0                           # todo: see if this value is a good one to use here
+
+class Event__Queue(Kwargs_To_Self):
+    events       : list
+    event_class  : type
+    log_events   : bool   = False
+    queue        : Queue
+    queue_name   : str    = random_text('event_queue')
+    queue_timeout: float  = QUEUE_WAIT_TIMEOUT
+    running      : bool
+    thread       : Thread = None
+
+
+    def __init__(self, **kwargs):
+        self.event_class = Schema__Event
+        super().__init__(**kwargs)
+
+    def __enter__(self):
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.stop()
+        return False
+
+    def new_event_obj(self, **kwargs):
+        return self.event_class(**kwargs)
+
+    def handle_event(self, event):
+        if self.log_events:
+            self.events.append(event)
+        return True
+
+    def send_event(self, event: Schema__Event):
+        if isinstance(event, Schema__Event):
+            if not event.timestamp:
+                event.timestamp = timestamp_utc_now()
+            if not event.event_id:
+                event.event_id = random_guid()
+            self.queue.put(event)
+            return True
+        return False
+
+    def send_data(self, event_data, **kwargs):
+        if type(event_data) is not dict:
+            event_data = {'data': event_data}
+        new_event = Schema__Event__Message(event_data=event_data, **kwargs)
+        if self.send_event(new_event):
+            return new_event
+
+    def send_message(self, message, **kwargs):
+        new_event = Schema__Event__Message(event_message=str(message), **kwargs)
+        if self.send_event(new_event):
+            return new_event
+
+    def start(self):
+        self.running = True
+        self.thread =  Thread(target=self.run_thread, daemon=True)
+        self.thread.start()
+        return self
+
+    def stop(self):
+        self.running = False
+        return self
+
+    def run_thread(self):
+        while self.running:
+            try:
+                event = self.queue.get(timeout=self.queue_timeout)
+                if isinstance(event, self.event_class):
+                    self.handle_event(event)
+            except Empty:
+                continue
+            except Exception as e:                          # todo: add way to handle this (which are errors in the handle_event), may call an on_event_handler_exceptions method
+                continue
+
+    def wait_micro_seconds(self, value=10):
+        time.sleep(0.000001 * value)
+
+
+    def wait_for_thread_ends(self):
+        self.thread.join()
+        return self

osbot_utils/helpers/pubsub/PubSub__Client.py

@@ -0,0 +1,53 @@
+from queue import Queue
+
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.pubsub.Event__Queue import Event__Queue
+from osbot_utils.helpers.pubsub.schemas.Schema__Event import Schema__Event
+from osbot_utils.helpers.pubsub.schemas.Schema__Event__Connect import Schema__Event__Connect
+from osbot_utils.helpers.pubsub.schemas.Schema__Event__Disconnect import Schema__Event__Disconnect
+from osbot_utils.helpers.pubsub.schemas.Schema__Event__Join_Room import Schema__Event__Join_Room
+from osbot_utils.helpers.pubsub.schemas.Schema__Event__Leave_Room import Schema__Event__Leave_Room
+from osbot_utils.utils.Misc import random_guid
+
+
+class PubSub__Client(Kwargs_To_Self):
+    event_queue       : Event__Queue
+    client_id         : str
+    received_messages : list[str]           # todo: fix this to be Events/Messages received via event_queue
+
+    def __init__(self, **kwargs):
+        self.client_id = kwargs.get('client_id') or random_guid()
+        super().__init__(**kwargs)
+
+    def connect(self):
+        event_connect = Schema__Event__Connect(connection_id=self.client_id)
+        self.send_event(event_connect)
+        return self
+
+    def disconnect(self):
+        event_connect = Schema__Event__Disconnect(connection_id=self.client_id)
+        self.send_event(event_connect)
+        return self
+
+    def join_room(self, room_name):
+        event  = Schema__Event__Join_Room(connection_id=self.client_id, room_name=room_name)
+        self.send_event(event)
+        return self
+
+    def leave_room(self, room_name):
+        event  = Schema__Event__Leave_Room(connection_id=self.client_id, room_name=room_name)
+        self.send_event(event)
+        return self
+
+    def send_data(self, event_data, **kwargs):
+        return self.event_queue.send_data(event_data, connection_id=self.client_id, **kwargs)
+
+    def send_event(self, event : Schema__Event):
+        event.connection_id = self.client_id
+        return self.event_queue.send_event(event)
+
+    def send_message(self, message, **kwargs):
+        return self.event_queue.send_message(message, connection_id=self.client_id, **kwargs)
+
+    def receive_message(self, message):
+        self.received_messages.append(message)      # todo: fix this to be Events/Messages received via event_queue

osbot_utils/helpers/pubsub/PubSub__Room.py

@@ -0,0 +1,13 @@
+from osbot_utils.base_classes.Kwargs_To_Self import Kwargs_To_Self
+from osbot_utils.helpers.pubsub.Event__Queue import Event__Queue
+from osbot_utils.helpers.pubsub.PubSub__Client import PubSub__Client
+
+
+class PubSub__Room(Kwargs_To_Self):
+    event_queue: Event__Queue
+    room_name  : str
+    clients    : set[PubSub__Client]
+
+    def send_to_clients__message(self, message):
+        for client in self.clients:
+            client.receive_message(message)